# GameFactory-3a Game Demo Package

This repository contains selected GameFactory-3a game demo artifacts for Unity and
Blender. The upload is intended to preserve the task inputs, generated game code,
reviewable engine projects, demo results, and redistributable assets needed to
inspect how each demo was produced.

This is an artifact package rather than a complete source checkout or a promise
that every demo can be regenerated in a clean environment. Some original assets
and demos are intentionally excluded because their licenses do not allow public
redistribution. Their absence from this package does not mean they were absent
from the original development environment.

## Package Overview

| Engine | Included demos | Main contents |
| --- | --- | --- |
| Unity 2022.3 URP | `gameC_fighting_arena` | Generated C# mechanics and UI, AI-generated 3D assets and motions, task definitions, reports, and a Unity project |
| Blender 4.5 LTS | `gameB_neon_circuit`, `gameC_ronin_clash`, `gameD_forest_explorer` | Generated Python game code, task specs, baked `.blend` scenes, demo videos, reports, GLB/GLTF models, textures, HDRIs, and motion files |

For each selected demo, the package includes as much of the following as its
redistribution rights and retained outputs permit:

- task requirements and structured task definitions;
- generated mechanic and UI source code;
- engine project or baked scene files for review;
- gameplay videos, thumbnails, event logs, and evaluation reports;
- generated or redistributable models, textures, environments, and animations;
- metadata connecting outputs to task IDs, prompts, seeds, and generation runs.

## Repository Layout

The contents of the local `upload/` staging directory are uploaded at repository
root; the outer `upload/` directory itself is not part of the dataset.

```text
repository-root/
├── README.md
├── unity/
│   ├── README.md                            # Unity-specific details
│   ├── test_samples/                       # Unity task definitions
│   └── gameC_fighting_arena/               # Unity demo code, assets, and project
└── blender/
    ├── README.md                            # Blender-specific details
    ├── test_samples/                       # Blender task definitions
    ├── gameB_neon_circuit/
    ├── gameC_ronin_clash/
    └── gameD_forest_explorer/
```

## Unity Demo

`gameC_fighting_arena` is an AI-generated 3D side-scrolling versus fighting
demo built with Unity 2022.3 URP. Its 3D objects were generated through Meshy;
motions were generated with MoMask and retargeted through Puppeteer. The upload
contains generated mechanic and UI code plus the assembled Unity project.

Only this Unity demo is included. Other Unity demos depended on third-party or
Unity Asset Store content that cannot be redistributed in this public package.

### Unity Structure

```text
unity/
├── README.md
├── test_samples/gameC_fighting_arena/    # Task definitions (jsonl + requirement txt)
│   ├── general_requirement.txt            # Game design spec
│   ├── 3D_object/object_tasks.jsonl       # 3D asset generation tasks (prompts)
│   ├── 3D_scene/scene_tasks.jsonl         # Scene generation tasks
│   ├── motion/motion_tasks.jsonl          # Motion generation tasks (prompts per action)
│   ├── tpose/tpose_tasks.jsonl            # T-pose image tasks
│   ├── audio/audio_tasks.jsonl            # Audio generation tasks
│   ├── cg_video/cg_tasks.jsonl            # CG video tasks
│   ├── mechanic/mechanic_tasks.jsonl      # Mechanic code-gen task definition
│   ├── ui/ui_tasks.jsonl                  # UI code-gen task definition
│   └── pipeline/pipeline_task.jsonl       # Full-pipeline integration task
│
├── gameC_fighting_arena/                   # Generated outputs + traceability
│   ├── assets/                            # Layer A: Generated 3D assets
│   │   ├── 3d_object/
│   │   │   ├── demoFighting_001/           # Warrior character (GLB + meta.json)
│   │   │   ├── demoFighting_002/           # Ninja character (GLB + meta.json)
│   │   │   ├── demoFighting_003/           # Ninja sword prop (GLB + meta.json)
│   │   │   └── demoFighting_004/           # Stone lantern prop (GLB + meta.json)
│   │   └── 3d_scene/
│   │       └── demoFighting_010/          # Arena scene meta (composed from generated assets)
│   │
│   ├── mechanic/                          # Layer B: Game mechanic code (C#)
│   │   └── demoFighting_070/
│   │       ├── Runtime/                   # 21 C# scripts
│   │       │   ├── FightingCharacterController.cs   # Movement, attack, block
│   │       │   ├── FightingCombatSystem.cs          # Hit detection, damage, hitstun
│   │       │   ├── FightingRoundManager.cs          # Timer, KO, best-of-5
│   │       │   ├── FightingCameraController.cs      # Side-view camera
│   │       │   ├── FightingComboSystem.cs           # Combo chains
│   │       │   ├── FightingUltimateSkill.cs         # Ultimate skill + VFX trigger
│   │       │   ├── FightingAIBehavior.cs            # AI opponent
│   │       │   ├── FightingThrowableProp.cs         # Stone lantern throw mechanic
│   │       │   └── ...
│   │       ├── Tests/                     # Unit tests
│   │       ├── mechanic_contract.json     # State/event/command bindings for UI
│   │       ├── context_used.json          # Agent context record
│   │       ├── package.json
│   │       ├── meta.json                  # Agent traceability (task_id, status, files)
│   │       └── demo_outputs/code_gen/     # task_packet, instructions, workspace_snapshot
│   │
│   ├── ui/                               # Layer C: UI code (C#)
│   │   └── demoFighting_ui_001/
│   │       ├── generated_ui/
│   │       │   ├── FightingHUD.cs         # HP bars, energy, timer, round indicator
│   │       │   ├── MatchEndScreen.cs     # Win/lose screen
│   │       │   ├── FightingUIBinder.cs   # Binds UI to mechanic contract
│   │       │   ├── Tests/                # UI tests
│   │       │   └── browser_play/         # Browser preview viewer
│   │       ├── meta.json                 # Agent traceability
│   │       └── demo_outputs/code_gen/    # task_packet, instructions
│   │
│   ├── pipeline/                         # Pipeline execution + Unity project
│   │   ├── unity_project/                # Complete Unity project (openable)
│   │   │   ├── Assets/
│   │   │   │   ├── Imported/
│   │   │   │   │   ├── Avatars/          # demoFighting_001 (warrior), demoFighting_002 (ninja)
│   │   │   │   │   ├── Weapons/          # demoFighting_003 (sword), demoFighting_007 (shuriken)
│   │   │   │   │   ├── Props/            # (empty)
│   │   │   │   │   ├── Environments/     # demoFighting_004 (stone lantern), demoFighting_005 (pavilion), demoFighting_006 (courtyard)
│   │   │   │   │   └── Motions/          # 14 retargeted FBX motion clips
│   │   │   │   ├── Generated/            # Animator controllers, prefabs, materials, animations
│   │   │   │   ├── A3GameFightingGameplay.Runtime/  # Mechanic C# scripts
│   │   │   │   ├── A3GameFightingUI.Runtime/        # UI C# scripts
│   │   │   │   ├── A3GameRuntime/                   # Runtime adapter
│   │   │   │   ├── Scenes/               # FightingArena.unity, FightingArenaGame.unity
│   │   │   │   └── Editor/               # Import scripts
│   │   │   ├── ProjectSettings/
│   │   │   └── Packages/
│   │   ├── scene_spec.json              # Scene assembly spec
│   │   ├── unityclient_play_report.json
│   │   ├── unityclient_generate_report.json
│   │   ├── unityclient_reimport_report.json
│   │   └── unityclient_texture_reimport_report.json
│   │
│   ├── run_meta.json                     # Run metadata (git sha, seeds, params)
│   ├── mechanic_results_summary.json     # Mechanic generation summary
│   └── ui_results_summary.json           # UI generation summary
```


## Unity Asset Inventory

### 3D Objects (all Meshy API generated)

| Task ID | Asset | Prompt | File |
|---------|-------|-------|------|
| demoFighting_001 | Warrior character | Muscular male arena fighter, T-pose, PBR | model.glb (8.5 MB) |
| demoFighting_002 | Ninja character | Lean male ninja, T-pose, PBR | model.glb (10.5 MB) |
| demoFighting_003 | Ninja sword | Short ninja sword, rigid prop, PBR | model.glb (9.6 MB) |
| demoFighting_004 | Stone lantern | Japanese stone arena lantern prop, PBR | model.glb (5.6 MB) |
| demoFighting_005 | Fighting pavilion | Two-story Japanese fighting pavilion, 13m wide | model.glb (16.2 MB) |
| demoFighting_006 | Courtyard enclosure | U-shaped Japanese fighting courtyard, 34m wide | model.glb (15.7 MB) |
| demoFighting_007 | Shuriken | Four-point ninja throwing star, 28cm | model.glb (7.0 MB) |

### 3D Scene (composed from generated 3D objects)

| Task ID | Scene | Components |
|---------|-------|------------|
| demoFighting_010 | Japanese stone fighting arena | demoFighting_005 (pavilion) + demoFighting_006 (courtyard) + demoFighting_004 (stone lanterns) |

The scene is composed entirely from generated 3D objects — no Unity Store or third-party assets.

### Motion (MoMask text-to-motion → Puppeteer rig → retargeted)

14 motion clips, 2 characters × 7 actions each. Each motion task directory contains
the full generation pipeline artifacts:

| File | Description |
|------|-------------|
| `motion.bvh` | MoMask raw output BVH |
| `motion_ik.bvh` | IK-processed BVH |
| `motion_raw.bvh` | Pre-processing BVH |
| `retargeted.fbx` | Final retargeted animation FBX (imported into Unity) |
| `animation.fbx` | Puppeteer rig animation |
| `rig.txt` | Puppeteer skeleton rig data |
| `skeleton.txt` | Skeleton joint hierarchy |
| `mapping.json` | Bone mapping (MoMask → Puppeteer) |
| `retarget_info.json` | Retarget metadata |
| `joints.npy` | Joint positions array |
| `mesh.obj` | Preview mesh |
| `preview.mp4` | Motion preview video |
| `meta.json` | Task traceability (prompt, seed, character) |

| Character | Actions |
|-----------|---------|
| Warrior | idle, move, light_punch, heavy_punch, kick, block, ultimate |
| Ninja | idle, move, light_punch, heavy_punch, kick, block, ultimate |

Motion files are also in the Unity project under `Assets/Imported/Motions/` as retargeted FBX clips.

### Mechanic Code (Agent-generated C#)

| Module | Scripts | Key Classes |
|--------|---------|-------------|
| A3GameFightingGameplay | 21 Runtime + 2 Tests | FightingCharacterController, FightingCombatSystem, FightingRoundManager, FightingCameraController, FightingComboSystem, FightingUltimateSkill, FightingAIBehavior, FightingThrowableProp |

### UI Code (Agent-generated C#)

| Module | Scripts | Key Classes |
|--------|---------|-------------|
| A3GameFightingUI | 4 Runtime + 2 Tests + browser_play | FightingHUD, MatchEndScreen, FightingUIBinder |

### Traceability

Every asset and code module includes a `meta.json` recording:

- `generator` — how it was produced (meshy, prepared_asset_substitution, agent code-gen)
- `source_path` — original source file if substituted
- `seed` — generation seed for reproducibility
- `requirement` / `prompt` — the input text that drove generation
- `task_id` — links back to the task definition in `test_samples/`

The `mechanic_contract.json` defines the state bindings, event bindings, and command
bindings that connect the mechanic layer to the UI layer, enabling automated UI-mechanic
integration verification.

### Run Metadata

- **Engine**: Unity3D 2022.3 URP
- **Run ID**: unity_fighting_20260816_132646
- **Git SHA**: d9f2b08

## Blender Demos

The `blender/` directory contains three selected demos:

| Game | Task | Description |
| --- | --- | --- |
| `gameB_neon_circuit` | `race_circuit_002` | Two-lap circuit race with two rivals |
| `gameC_ronin_clash` | `fight_bo3_003` | Best-of-three 2.5D arena fight |
| `gameD_forest_explorer` | `forest_explore_001` | Third-person forest combat and exploration |

Each Blender demo provides its generated `game.py`, resolved `spec.json`, a
reviewable `session.blend`, reports and event records, and the available demo
media and assets. The asset set includes selected GLB/GLTF models, textures,
HDRIs, and, for Forest Explorer, generated rig and retargeted FBX/BVH motion
outputs. See `blender/README.md` for the per-demo layout and inventory.

The baked `.blend` files and recorded gameplay are the primary review artifacts.
Regeneration may require the full GameFactory-3a source tree, Blender adapters,
and dependencies that are not duplicated in this upload.

## Asset Licensing And Exclusions

The package contains project-generated code and task metadata, AI-generated
assets where redistribution is permitted, and selected redistributable assets.
Included Kenney assets retain their upstream license files. Poly Haven and other
included sources retain the available provenance metadata. Meshy-generated asset
records and motion-generation metadata are kept with their corresponding tasks.

The following are intentionally not included:

- demos or source assets governed by Unity Asset Store or other licenses that
  do not permit redistribution;
- the complete shared asset library when only a subset is needed by the selected
  demos;
- unrelated demos, duplicate verification runs, caches, temporary builds,
  backups, and intermediate logs;
- external engines, generation services, and the full GameFactory-3a runtime or
  adapter source tree.

Users of this package are responsible for following the license and terms of
each included upstream asset and generation service. The game designs, task
definitions, and project-generated code are provided as GameFactory-3a demo
artifacts.

## Large Files

The package includes large `.blend`, GLB, FBX, video, and image files. Use Git
LFS or Hugging Face's Xet-backed upload path rather than regular Git blob storage.