User Manual for AI-Assisted Game Creation

A practical manual for the current Game prototype workflow.

The AI Game Assistant is designed to accelerate game creation without forcing the author to manually build every level, character, question, and information block. The platform prepares a structured JSON package containing the game requirements and the instructions needed by an external AI model. The AI completes that package, and the completed JSON is brought back in for inspection, media enrichment, and publication.

This manual separates the different AI components because they serve different purposes. In the working interface, several functions may still use the generic label "AI Assistant"; for clarity, the manual uses more precise functional names.

Who should use this manual

• Game authors and facilitators creating ERUDITA-style learning games.
• Project teams prototyping games before transferring them to the live platform.
• Editors reviewing generated levels, characters, questions, scoring, and media.
• Developers and testers validating the evolving AI-assisted workflow.

What this manual does not assume

• You do not need to write JSON manually.
• You do not need an API key for the Create Game workflow.
• You do not need to predetermine every level before generation; the AI should do part of that design work.

Three distinct AI functions should not be confused.

The author begins by choosing the amount of structure the new game needs.

Figure 1. Current Create a new Game screen in the ERUDITA platform.

Choose the smallest mode that contains the functionality you genuinely need. A larger mode does not automatically produce a better game; it creates a larger structure and therefore a larger AI generation task.

From game idea to a saved, editable game.

Tell the AI what the levels must achieve, not exactly what every level must contain.

5.1 The central design rule

The initial brief should describe the game's purpose and the design logic. Avoid writing the complete level sequence yourself inside the setup fields. If the author defines every level in advance, the AI is forced to reconcile too many local instructions with the global game rules, and the generation becomes more confusing and less useful.

5.2 Recommended input fields

5.3 Why this works

• The author defines intent and quality criteria.
• The platform provides the technical schema and required fields.
• The AI model performs the generative work inside that schema.
• The author reviews, negotiates, and iterates rather than accepting the first answer blindly.

The JSON is the hand-off package between ERUDITA and the external AI.

After the brief is completed, the platform generates an original JSON file. Think of this file as a self-contained work order for the AI model.

6.1 The original JSON contains two kinds of information

1. System specifications: the game type, required sections, fields, keys, level structure, language logic, scoring fields, and other rules the AI must respect.
2. Your design requirements: the description, learning objectives, level-generation goals, character goals, language choices, and other instructions entered for this specific game.

6.2 Opening the JSON is optional

You can save and inspect a JSON file with a code editor such as Visual Studio Code, but opening it is not required for the normal workflow. Manual editing should be reserved for users who understand the JSON structure and know how to preserve valid syntax.

The AI model is used as the content engine, while REBOOT PLATFORM controls the structure.

7.1 First pass: paste only the JSON

1. Open a new chat in the AI model you want to use.
2. Paste the complete original JSON into the dialogue box.
3. Do not add a second, competing description of the game on the first pass. The instructions are already inside the JSON.
4. Let the model complete the structure and return the full JSON.

7.2 Copy the result correctly

• Use the AI interface's Copy button for the complete code block or response.
• Do not manually highlight only the visible text if there is any risk of missing the first or last lines.
• Do not copy formatted page content that may include hidden styling or unrelated interface text.
• If you want to keep a reusable file, convert the copied plain text into a .json file with a text-to-file tool or code editor.

7.3 Prototype observations about AI models

The following comparison reflects one prototype testing session and should be treated as an operational note, not a permanent ranking. Free limits, context windows and model behaviour change frequently.

Validation is the bridge between AI output and the REBOOT editor.

8.1 Import

Return to the REBOOT platform. Paste the completed JSON into the import area or drag the saved JSON file into the interface, then select Inspect JSON.

8.2 Understand the result

8.3 Human review before continuing

• Game title and overall description.
• Number of levels and progression.
• Level descriptions and missions.
• Questions, answer options and scoring.
• Characters and information blocks, if the chosen game type uses them.
• Language versions and consistency between languages.
• Any field that looks suspiciously empty, generic, or repetitive.

8.4 Improve weak content without rebuilding the game

If the JSON is structurally valid but the content is too vague, return to the AI conversation and ask for a targeted improvement. The model should preserve the same JSON keys and return the complete updated JSON.

If the model becomes confused or repeatedly breaks the structure, start a new chat and repeat the process with the original JSON rather than continuing to repair a deteriorating conversation.

Text generation is only the first half of the game-building process.

9.1 Where media can be added

• Game-level media: cover image, introduction video, or other assets representing the whole game.
• Level-level media: images, vertical videos, horizontal videos, YouTube/Vimeo content or other media associated with a specific level.

9.2 Media must be uploaded

Selecting a media file is not the same as uploading it. The asset must be uploaded to the server before it can be reliably used in the published game. The prototype allows the author to upload media progressively, which is useful on slow connections or when a game contains many assets.

9.3 Working terminology for media navigation

Each level can use the presentation mode that best fits its media. "Vertical" or "horizontal" should describe the media orientation, while the navigation label should describe how the player moves through the media.

The current prototype keeps unpublished work in browser memory.

10.1 The browser-memory warning

10.2 Before publishing

• Inspect JSON returns a valid result.
• Core text fields are complete and coherent.
• Questions and scoring are present where required.
• At least one required media asset has been uploaded.
• Presentation modes are set for the levels that use media.
• No prototype database field is missing a default value.

10.3 Publish and save

When the review is complete, continue to the publication step. Saving generates a new game in the dashboard/editor. From that point, the game is no longer only a temporary browser build: it can be opened as a normal game and edited through the standard editor.

AI generation is a starting point, not the end of authorship.

Once saved, the game can be edited in the normal REBOOT editor. This is where the author can make precise changes that are inefficient to negotiate through JSON generation.

Typical post-generation edits

• Rewrite or shorten individual texts.
• Correct a question, answer, or score.
• Add, replace, or remove media.
• Change the presentation mode of a specific level.
• Delete content that the AI overproduced.
• Add game-specific logic that requires human judgment.
• Activate or deactivate optional AI features.

The intended workflow is therefore hybrid: AI for breadth and first-pass construction; human editing for narrative quality, pedagogy, accuracy, and final experience design.

The platform is evolving from static generated content toward real-time interaction.

12.1 Game Assistant / Oracle

The Game Assistant is an optional player-facing AI helper that can be activated across levels. It is conceptually different from the AI Game Builder: the Builder helps the author create the game, while the Game Assistant helps the player inside the game.

• One shared assistant can be generated for the whole game.
• It can be enabled or disabled according to the game design.
• Its role, limits, and behavior must be defined so it supports rather than replaces player reasoning.

12.2 AI Co-Player / Personal Virtual Player

The proposed AI Co-Player goes further. The human player can talk in real time with a virtual character connected to the story. Instead of receiving only pre-recorded or pre-written information, the player can question the character and explore the narrative interactively.

12.3 Player Chat Conversations

The Player Chat Conversations area is a control and audit function: it allows the team to review conversations that real players have had with AI characters. It is not the same as the authoring assistant.

AI can help assess the game, not only generate it.

A major value of the emerging workflow is the ability to analyze a complete game after generation. The audit layer can support the author in identifying what works, what is missing, and where the player experience may fail.

Examples of useful audit questions

• Does the level sequence actually increase in complexity?
• Are some levels repetitive or too vague?
• Are all characters necessary and meaningfully differentiated?
• Do questions require reasoning or merely recall?
• Are scores balanced and consistent?
• If the game uses GPS: are locations too far apart for the planned game time?
• Are the distances between monuments realistic for the intended route?
• Is the total game duration compatible with the event or workshop?
• What are the strengths, weaknesses, risks and missing elements of the current design?
• Does the AI assistant support critical thinking, or does it give answers too easily?

Most failures are either incomplete copy/paste, malformed JSON, missing fields or unpublished media.

A repeatable process for authors and project teams.

Before generation

• Decide whether the game is Simple, Plus or Complex.
• Write a concise game description and clear learning objectives.
• Define the desired progression and minimum number of levels.
• Define the role of characters without over-specifying every scene.
• Decide which language versions are genuinely needed.

During AI generation

• Keep the original JSON unchanged as your recovery copy.
• Use a new AI chat for the first pass.
• Paste the JSON only; avoid duplicate instructions.
• Copy the complete returned JSON using the platform copy control.
• Iterate only on specific weaknesses once a valid complete version exists.

Before publication

• Validate structure in REBOOT.
• Read the generated content as a game designer, not as a technician.
• Check progression, questions, scoring and language consistency.
• Upload media and test the chosen navigation mode.
• Run an audit for timing, distance, repetition, gaps and critical-thinking quality.
• Save/publish before leaving the browser session.

After publication

• Use the REBOOT editor for precise changes.
• Prototype the game with real users before final deployment.
• Review AI conversations if player-facing AI is enabled.
• Update the manual when interface labels or AI services change.

A shared vocabulary will make the interface and future manual easier to understand.

Items still evolving

• Final navigation label for the current media mode.
• Final visual color coding of AI-related menu items.
• Runtime model/service used by the player-facing Game Assistant.
• Final configuration workflow for character-specific AI Co-Players.
• Default values for newly introduced visual/media database fields.
• Exact persistence rules during long authoring sessions and any future autosave mechanism.

1. 01
   Choose game typeSimple, Plus or Complex.
2. 02
   Write the briefDescription, objectives, level-generation goals, character goals and languages.
3. 03
   Generate original JSONREBOOT packages the rules, fields, and your requirements.
4. 04
   Send JSON to an AI modelPaste the complete JSON into a normal AI chat; initially add no extra instructions.
5. 05
   Copy the completed JSONUse the model's copy function; do not manually select partial output.
6. 06
   Import and InspectPaste or drag the JSON into REBOOT and run Inspect JSON.
7. 07
   Refine if neededAsk the AI to improve weak sections while preserving the JSON structure.
8. 08
   Add and upload mediaAdd game and level images/videos; choose the presentation mode.
9. 09
   Review and PublishCheck content, questions, scores, media, and validation messages.
10. 10
    Save and editThe generated game appears in the dashboard/editor for normal editing.