teawhite/GameCrafter-Data-v3

GameCrafter v3 Paired Data

Paired training data for an action-conditioned 2.5D game world model whose control signal is a per-pixel numeric semantic map. All frames come from 10 game scenes built in Unreal Engine 5.8. Each frame stores:

• the rendered RGB frame;
• a pixel-aligned semantic id map (one integer per pixel);
• a structural "whitebox" render;
• the player's 5-dim action (W, A, S, D, attack);
• full camera and actor metadata.

What this is for

We train a video-to-video world model on top of Wan2.2-TI2V-5B.

• Condition: the semantic id map. Each number is a semantic class (0 = sky, 1 = terrain, 2 = paving, 5 = vegetation, …) and is turned into an embedding inside the model.
• Style: the first RGB frame. The model learns to render each class in the look of the given first frame.
• Actions: the player's keys, one action prompt per 0.25 s.

At inference time the semantic map does not come from a game engine: the user authors it directly. A numeric map gives us properties that engine-based or whitebox-based v2v pipelines don't have:

• Controllable: changing a number changes what is rendered there.
• Real-time: the input is just an integer map, with no engine in the loop.
• Extensible: a 2.5D level is one large number map that can be extended in any direction.
• Editable: editing the map is editing the world.

Because the goal is to learn control from the number map, the data includes in-scene augmentations: mirrored worlds, relocated and duplicated props, and randomized cameras. The same object then appears at different screen positions and in different neighbourhoods, and the model cannot simply memorise each scene's layout.

At a glance

Scenes	10 UE 5.8 scenes, isometric orthographic camera (2.5D)
Frames	384,000 at 16 fps (6.67 h of game time)
Default scenes	5.0 h (10 scenes × 30 min, two 15-min runs with different seeds)
Augmented scenes	1.67 h (10 scenes × 10 min)
Resolution	1280 × 704
Ready-made 81-frame clips	4,466
Size	about 100 GB
Label check	0 invalid semantic pixels across the whole set
Action check	0 key changes inside any 0.25 s block

Per-frame contents

Each frame is one WebDataset sample inside a tar shard. The sample key is the 6-digit frame index within its run.

File in tar	Content
{frame}.jpg	RGB, 1280×704, JPEG. Quality 90 for the def_a runs of scenes 01–03, quality 85 for everything else.
{frame}.ids.png	Semantic id map, single-channel uint8, lossless, pixel-aligned with the RGB.
{frame}.whitebox.jpg	Whitebox render (structural geometry plus articulated capsules for characters), JPEG q95. 01_Sunlit_Mediterranean_Courtyard/def_a stores .whitebox.png instead.
{frame}.json	Metadata: world_to_clip, world_to_view, projection, ortho_width_cm, camera pose, player and boss position / velocity / state / health, the action, episode, camera_variant, mirrored_world, the bot personality, and label_invalid_pixels.

RGB, semantic ids and whitebox are rendered synchronously at the same simulation step. There is no HUD, motion blur or TAA.

Semantic classes

id	class	id	class	id	class
0	sky / background	3	architecture	6	prop
1	terrain	4	rock	10	player
2	paving (roads, floors)	5	vegetation	11	boss

Actions

actions.npy is an array of shape (N, 5) with columns [w, a, s, d, attack]. Row i holds the keys held from frame i to frame i+1. attack = 1 only on the frame where the attack key was pressed.

Actions are aligned to the model's action prompts:

• Decisions are only made on frames with i % 4 == 0, so keys never change inside a 0.25 s block.
• An attack is a single press at the start of a block.
• Key segments last at least 4 frames; the median is 8–16 frames.
• actions_block_0.25s.npy has shape (N/4, 5). Row b is the action prompt for frames 4b … 4b+3, with attack set if it was pressed anywhere in the block.

The actions come from a scripted player bot built to behave like a person:

• Each episode draws a random "personality": aggressiveness, idle rate, key noise, detour tendency, hold length and combo length.
• The bot switches between roaming (explore / detour / pause), seeking the boss, fighting (approach, strafe, retreat, combos, waiting) and getting itself unstuck.
• A new episode starts when the player dies, when the boss dies, or when seeking the boss times out.

Clips

clips_81.json lists 81-frame training clips as {start, end, episode, camera_variant}:

• start % 4 == 0, with a stride of 80, so neighbouring clips share one frame.
• A clip never crosses an episode boundary or a camera change.
• A clip is the first frame plus 20 groups of 4 frames, matching Wan's 4× temporal compression. Latent group k (frames s+4k+1 … s+4k+4) is driven by block s/4 + k.

Runs

Each scene has four runs:

Run	Length	Content
def_a, def_b	15 min each (14,400 frames)	Default scene, two different seeds, roaming plus boss fights
aug_mirror	5 min (4,800 frames)	Whole world mirrored, props relocated and duplicated, random camera per episode
aug_layout	5 min (4,800 frames)	Props relocated and duplicated, random camera per episode (no mirror)

About the augmentations:

• World mirror: every visible actor is mirrored about a vertical plane, and local light directions are mirrored with it. Sun, sky and fog stay unchanged, so the lighting style is kept.
• Prop relocation and duplication: props and vegetation are traced onto terrain or paving, checked for overlaps, and kept away from spawn points and the main route.
• Random camera: each episode gets a random yaw, pitch and ortho width.

Scene	Default	Aug	Episodes	Clips	Fight share*	Relocated / duplicated (aug)
01 Sunlit Mediterranean Courtyard	30 min	10 min	32	463	12.5%	1,519 / 160
02 Autumn Woodland Shrine	30 min	10 min	47	456	19.0%	679 / 160
03 Desert Caravanserai	30 min	10 min	152	398	59.8%	38 / 51
04 Snowbound Mountain Outpost	30 min	10 min	49	455	19.4%	189 / 100
05 Japanese Spring Sanctuary	30 min	10 min	41	458	16.7%	4,553 / 160
06 Overgrown Tropical Water Temple	30 min	10 min	56	452	20.9%	1,379 / 160
07 Steampunk Foundry District	30 min	10 min	47	458	18.2%	5 / 10
08 Gothic Cathedral Quarter	30 min	10 min	42	454	19.0%	16 / 20
09 Dense Cyberpunk Neon District	30 min	10 min	87	432	25.9%	61 / 123
10 Underwater Research Habitat	30 min	10 min	74	440	20.7%	50 / 63

* Share of frames in which the bot is fighting, over the default runs.

Repository layout

data/<scene>/<run>/frames-000000.tar     frames 0–1599 of the run (WebDataset shard, 1,600 frames each)
data/<scene>/<run>/frames-001600.tar     frames 1600–3199, …
data/<scene>/<run>/index/
    actions.npy                (N,5) uint8 [w,a,s,d,attack]
    actions_block_0.25s.npy    (N/4,5) one action prompt per 0.25 s
    episodes.npy               (N,) episode id
    actions.csv                per-frame actions + bot mode + player/boss state and HP
    frames.jsonl               compact per-frame metadata (camera matrices, actor positions, …)
    clips_81.json              81-frame training clips
    meta.json                  run statistics
    capture_result.json        capture settings and augmentation counts
    scene_actors.json          static-mesh inventory of the scene before augmentation (with semantic tags)
summary.csv / summary.json     statistics for all 40 runs
previews/                      one 81-frame preview per run (RGB | semantic | whitebox | overlay, with key overlay)
thumbs/                        thumbnails (RGB | semantic | whitebox)

Loading a clip

import io, json, tarfile
import numpy as np
from PIL import Image
from huggingface_hub import hf_hub_download

REPO = "teawhite/GameCrafter-Data-v3"
scene, run = "05_Japanese_Spring_Sanctuary", "def_b"
get = lambda p: hf_hub_download(REPO, f"data/{scene}/{run}/{p}", repo_type="dataset")

clips = json.load(open(get("index/clips_81.json")))
blocks = np.load(get("index/actions_block_0.25s.npy"))
c = clips[10]; s, e = c["start"], c["end"]          # 81 frames

def frames(lo, hi):                                   # read frames [lo, hi) from the 1,600-frame shards
    out = {}
    for shard in range(lo // 1600 * 1600, hi, 1600):
        with tarfile.open(get(f"frames-{shard:06d}.tar")) as tf:
            for m in tf:
                key, ext = m.name.split(".", 1)
                if lo <= int(key) < hi:
                    out.setdefault(int(key), {})[ext] = tf.extractfile(m).read()
    return [out[i] for i in range(lo, hi)]

clip = frames(s, e)
rgb = np.stack([np.asarray(Image.open(io.BytesIO(f["jpg"]))) for f in clip])         # (81,704,1280,3)
ids = np.stack([np.asarray(Image.open(io.BytesIO(f["ids.png"]))) for f in clip])     # (81,704,1280) uint8
act = blocks[s // 4 : s // 4 + 20]                                                   # (20,5) one prompt per latent group

The shards follow the WebDataset layout, so webdataset.WebDataset(urls) can stream them as well. Frames inside a shard are stored in order.

Capture details

• Engine and camera: Unreal Engine 5.8.3 with an isometric orthographic camera that follows the player.
• Timing: offline fixed-timestep simulation at 48 Hz, keeping every 3rd step, so frames are 16 fps of game time independent of wall-clock speed. 6.67 h of data took about 5.5 h to capture.
• Warm-up: each run waits until shader and asset compilation is idle, then runs an all-pass warm-up before the first saved frame. Every frame's labels are checked for invalid pixels.

Known limitations

• Old bot policy in one run: 01_Sunlit_Mediterranean_Courtyard/def_a was captured with an earlier bot policy. It has about 5% fighting, and its whitebox is PNG.
• Scene 03 is fight-heavy: about 60% of frames are fighting, and frequent deaths give many short episodes.
• Prop relocation strength varies by scene: in scenes 01, 02, 05 and 06, props and vegetation are separate actors, so hundreds to thousands move per run. In 03, 04 and 07–10 most props are baked into merged meshes, so only a few to about a hundred move per run. For those scenes the in-scene variation mostly comes from the world mirror and random cameras.
• Low-contrast whitebox: the whitebox render has only about 20 grey levels, so per-frame contrast normalisation is recommended.