Datasets:

YY222
/

GameFactory-3A-Assets

Modalities:

Image

Text

Formats:

text

Size:

1K - 10K

Libraries:

Datasets

Dataset card Data Studio Files Files and versions

xet

Community

Dataset Viewer

Auto-converted to Parquet Duplicate

Split (1)

test · 1.04k rows

text stringlengths 0 241
Two-lap circuit with first/third-person camera switch.

Two-lap circuit race against two rivals. Player car is a downloaded 3D vehicle on a normal racetrack. C/V switches first-person cockpit and third-person chase; the unattended demo shows both.
2.5D ring fight, skinned punch/kick, sun shadows off.

Best-of-three side-scroller on a 3D ring. Two skinned characters with walk, punch and flying-kick (jump) clips; W/S steps into the stage. Sun shadows off so the fighters stay readable.
Forest explorer: chest, Meshy knights, slash and light-arrow.

Third-person enchanted glade. A Black Eagle knight opens one supply chest
at the start (no weapon pickup), then fights Celestial Steel hostiles;
melee slash and a glowing light-arrow projectile. Bright daylight.
# 3D Object Generation Requirements — gameC_fighting_arena

## Overview
Generate game-ready 3D models for the fighting arena game. All character models
are generated from T-pose reference images using TRELLIS.2 or Hunyuan3D-2.1.
Weapon, prop, and architectural models are generated from reference images
using TRELLIS.2, TripoSG, or Meshy.

## Model Backend
- Characters: TRELLIS.2 / Hunyuan3D-2.1 (T-pose image → 3D model)
- Weapons / Props: TRELLIS.2 / TripoSG (ref image → 3D model)
- Architecture: Meshy image-to-3D (ref image → textured GLB)

## Quality Requirements

### Character Models (Warrior, Ninja)
- Triangle count: ≤100,000 tris
- PBR textures: 2048×2048
- T-pose orientation: arms along X-axis, feet on ground plane
- UV-mapped, game-ready, rigged-ready topology
- Realistic style matching Mortal Kombat visual reference

### Weapon / Prop Models
- Triangle count: ≤10,000–15,000 tris
- PBR textures: 2048×2048
- UV-mapped, game-ready

### Architectural Models
- Triangle count: ≤70,000 tris
- Embedded PBR textures with readable wood, stone, metal, and roof surfaces
- Preserve open interiors and continuous walkable floors
- Use meters for target scale; gameplay collision is authored separately in-engine

## Assets to Generate

### 1. Muscular Warrior (demoFighting_001)
- Source: T-pose reference image (generated by tpose task)
- Prompt: "Muscular male warrior in traditional Japanese fighting hakama, bare-chested with arm bandages and battle tattoos, aggressive expression, short hair, realistic style, T-pose, game-ready, PBR textures"
- Decimation target: 100000
- Texture size: 2048

### 2. Ninja (demoFighting_002)
- Source: T-pose reference image (generated by tpose task)
- Prompt: "Lean male ninja in full black bodysuit with face mask only showing eyes, wrist gauntlets with hidden blades, ninja headband, realistic style, T-pose, game-ready, PBR textures"
- Decimation target: 100000
- Texture size: 2048

### 3. Ninja Short Sword / Blade (demoFighting_003)
- Source: reference image
- Prompt: "Traditional Japanese ninja tanto short sword with black scabbard, curved blade, wrapped handle, realistic, game-ready, PBR textures"
- Decimation target: 10000
- Texture size: 2048

### 4. Stone Lantern Prop (demoFighting_004)
- Source: reference image
- Prompt: "Traditional Japanese stone lantern (toro), weathered granite texture, hexagonal cap, game-ready, PBR textures"
- Decimation target: 10000
- Texture size: 2048

### 5. Two-Story Fighting Pavilion (demoFighting_005)
- Source: `ref_images/gatehouse_pavilion_ref.png`
- Target bounds: approximately 13 m wide × 4.6 m deep × 6.2 m high
- Layout: fully open front with solid left, right, and rear walls
- Ground floor: broad, flat, unobstructed combat space
- Upper floor: continuous combat platform at approximately 2.7 m
- Access: 1.4 m wide left staircase plus direct double-jump access
- Materials: weathered timber, stone foundation, ceramic tiles, aged metal trim
- Decimation target: 70000
- Texture size: 2048
- Preserve the architectural floor; do not apply inferred ground-plate removal
- Generate visual geometry only. Unity supplies simplified colliders for both
floors, stairs, walls, columns, railings, and the open front boundary.

### 6. U-Shaped Fighting Courtyard (demoFighting_006)
- Source: `ref_images/courtyard_enclosure_ref.png`
- Target bounds: approximately 34 m wide × 18 m deep × 3.4 m high
- Layout: one continuous stone-tile floor with solid left, right, and rear walls
- Front boundary: fully open, with no generated gate or obstruction
- Composition: the separate 26 m wide pavilion is centered on this floor while
both side lanes remain open for movement and combat
- Materials: weathered dark stone, muted vermilion timber, charcoal wall caps,
and restrained aged-bronze trim matching the pavilion
- Decimation target: 70000
- Texture size: 2048
- Preserve the generated floor; it replaces the old plain visual arena plane
- Generate visual geometry only. Unity supplies one continuous gameplay floor
and simplified left, right, and rear wall colliders.

### 7. Ninja Shuriken (demoFighting_007)

End of preview. Expand in Data Studio

YAML Metadata Warning:empty or missing yaml metadata in repo card

Check out the documentation for more information.

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.

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

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.

Downloads last month: 58