teawhite/GameCrafter-Data-v4

GameCrafter v4 Paired Data

Version 4 of the paired training data for an action-conditioned 2.5D game world model whose control signal is a per-pixel numeric semantic map. It follows GameCrafter-Data-v3 and uses the same 10 Unreal Engine 5.8 scenes, camera, frame format and action alignment. 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);
• camera, actor, character, appearance and event metadata.

What changed from v3

v4 was captured to address four weaknesses of v3:

1. Mid-episode dynamic events. Objects are deleted, replaced or spawned while an episode is running: mostly props and rocks, sometimes trees and buildings. The RGB frame and the semantic map change on the same frame, and every event is logged with its frame, object, class change and position.
2. Same layout, several appearances. The same layout and the same bot seed are captured again with a different look: golden hour, night, overcast, snow, autumn or a per-class random palette. The map and the semantic ids stay the same; only the appearance changes.
3. Random characters. Each episode the player and the boss get a random model, material and colour, and a random scale. The actual height and collision-capsule size are written every frame, and the player and boss height ranges overlap.
4. More varied layouts and behaviour. Two layouts per scene with heavier prop shuffling and duplication plus procedural rocks and props, which raises the rare rock and prop classes about 7×. The bot keeps standing-still segments, has a capped fight budget, and adds backtracking, wall-hugging, pushing into obstacles and disengaging.

At a glance

Scenes	10 UE 5.8 scenes, isometric orthographic camera (2.5D)
Runs	100 runs of 5 min (4,800 frames each)
Frames	480,000 at 16 fps (8.33 h of game time)
Resolution	1280 × 704
Appearances	7 (default, golden, night, overcast, snow, autumn, palette)
Dynamic events	4,751 (spawn 1,681 / delete 1,569 / replace 1,501)
Ready-made 81-frame clips	5,512, of which 4,141 (75%) contain at least one event
Same-layout appearance groups	30
Size	about 141 GB
Label check	0 invalid semantic pixels across the whole set
Action check	0 key changes inside any 0.25 s block

Runs and pairing

Runs are named <layout>_<appearance>_s<bot seed>, for example L2_night_s642. Each scene has 10 runs:

Runs	Layout	Bot seed	Appearances	Pairing
3 per scene	L1 (original world, shuffled)	s<scene>41	default + 2 others	Identical up to the first divergence (see below)
3 per scene	L2 (mirrored world, shuffled)	s<scene>42	default + 2 others	Identical up to the first divergence
4 per scene	L1	s<scene>43	default + 3 others	Frame-identical for all 4,800 frames

Runs of the same scene with the same layout and the same bot seed form a group. They share the layout, the spawned rocks and props, the bot's decisions, the characters and the dynamic events; only the appearance differs.

Determinism. The s43 groups were captured after a fix that pins the tick order of player and boss. All 30 pairs in those groups have identical player and boss state on all 4,800 frames (30/30). Their semantic maps agree on 99.2–99.9% of pixels per frame; the remaining pixels are at foliage edges, where the wind-animation phase differs between launches.

The s41 / s42 groups were captured before the fix. They start identical but can diverge after the first close-range hit. Of their 40 pairs, 3 stay identical for the whole run, and the median pair matches on 20% of frames. pairs_v4.json lists, for every pair, the number of identical leading frames (identical_prefix_frames) and the share of frames where both characters are within 2 cm (state_match_frac). Use only the matching frames when you need exact pairs from these groups.

Appearances

Appearance	Hours	What changes
default	2.50 h	the scene as authored
golden	1.00 h	low sun, warm grade, long shadows
night	1.00 h	moonlight plus boosted local lights; exposure calibrated per scene
overcast	1.00 h	dim diffuse sun, strong sky light, denser fog
snow	0.92 h	snow on up-facing surfaces, cold grade
autumn	0.92 h	vegetation shifted to orange/red, warm sun
palette	1.00 h	random hue / saturation / brightness per semantic class

Lighting changes (sun direction and intensity, sky light, fog, white balance, saturation) come from the engine. Material colour changes are applied per semantic class in a post-process material, so they never touch the semantic map. For night, two 32-frame probe captures before each run solve for the exposure that puts the mean image brightness at about 30% of the scene's default (between 18 and 32 on a 0–255 scale), because the share of light coming from local lamps differs a lot between scenes.

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 q85
{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
{frame}.json	Per-frame metadata (fields below)

New fields in the per-frame json, in addition to the v3 fields (world_to_clip, camera pose, ortho_width_cm, actors with position / velocity / state / health, action with keys, block and bot_mode, episode, camera_variant, mirrored_world, personality, label_invalid_pixels):

• appearance: the appearance name. The full parameters (sun pitch / yaw / intensity, sky, fog, white temperature, saturation, exposure, per-class recolour) are in index/capture_result.json under appearance.
• characters: one entry each for the player and the boss with model (player_native, boss_native, manny, quinn), material_variant, scale, height_cm, capsule_radius_cm, capsule_half_height_cm and skin_hue_sat_bright.
• events: the dynamic events that become visible on this frame. Each has type (spawn, delete, replace, restore_on_reset), removed and/or added objects with class_id, class, mesh, position_cm and radius_cm, plus block and episode.

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

Pixel share over the whole set: paving 33.8%, architecture 21.6%, vegetation 19.9%, terrain 17.0%, prop 3.7%, rock 3.6%, player 0.2%, boss 0.2%.

Actions and clips

Same as v3:

• actions.npy has shape (N, 5) with columns [w, a, s, d, attack]; row i holds the keys held from frame i to frame i+1.
• Decisions are only made on frames with i % 4 == 0, so keys never change inside a 0.25 s block. actions_block_0.25s.npy has shape (N/4, 5), one action prompt per block.
• clips_81.json lists 81-frame clips (start % 4 == 0, stride 80) that never cross an episode or camera change. In v4 each clip also lists its events with frame offsets.

Dynamic events

A candidate event fires every 10–36 action blocks (2.5–9 s). Delete, replace and spawn are about equally likely. Candidates are weighted by size, and buildings are accepted with a lower probability. Spawned objects are procedural rocks (1–4 squashed spheres / cubes with the scene's stone materials), procedural props (crate, crate stack, barrel, pillar, urn, bench) or copies of the scene's own meshes, placed on the ground with their stencil and semantic tag. All changed objects are restored when a new episode starts.

Action	Class	Count
removed	vegetation	1,694
added	prop	1,281
added	rock	1,224
removed	rock	719
removed	prop	625
added	vegetation	460
added	architecture	217
removed	architecture	32

Characters

Each episode, the player and the boss independently pick a model (the scene's player rig, the scene's boss rig, UE Manny or UE Quinn), a material slot arrangement and a skin recolour, then a scale relative to the native player height: 0.7–2.0× for the player and 0.75–2.2× for the boss, with a 45% chance of a near-normal 0.85–1.2×. The capsule follows the model and scale.

• Height, p5–p95: player 143–345 cm, boss 152–378 cm; the ranges overlap between 152 and 345 cm.
• Player models: player_native 34%, manny 30%, boss_native 20%, quinn 16%.
• Boss models: boss_native 36%, manny 25%, quinn 22%, player_native 17%.

Behaviour

Share of frames by bot mode over the whole set: explore 36.8%, fight 17.4%, seek_boss 12.5%, unstick 6.9%, dead 6.0%, pause 5.7%, detour 4.5%, retreat 4.0%, backtrack 3.0%, wallhug 1.5%, push_obstacle 1.2%, disengage 0.6%. Frames with no key held: 19.6%.

Scene	Runs	Length	Episodes	Clips	Events	Fight share*
01 Sunlit Mediterranean Courtyard	10	50 min	74	568	483	11.4%
02 Autumn Woodland Shrine	10	50 min	76	564	498	20.2%
03 Desert Caravanserai	10	50 min	155	525	424	54.3%
04 Snowbound Mountain Outpost	10	50 min	79	551	496	18.6%
05 Japanese Spring Sanctuary	10	50 min	81	563	511	12.4%
06 Overgrown Tropical Water Temple	10	50 min	99	552	490	15.1%
07 Steampunk Foundry District	10	50 min	71	563	502	16.5%
08 Gothic Cathedral Quarter	10	50 min	72	557	432	15.9%
09 Dense Cyberpunk Neon District	10	50 min	122	529	473	22.2%
10 Underwater Research Habitat	10	50 min	112	540	442	27.5%

* Share of frames in which the bot is fighting or retreating.

Repository layout

data/<scene>/<run>/frames-000000.tar     frames 0–1599 of the run (WebDataset shard)
data/<scene>/<run>/frames-001600.tar     frames 1600–3199
data/<scene>/<run>/frames-003200.tar     frames 3200–4799
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, character model and scale, event count
    frames.jsonl               compact per-frame metadata
    clips_81.json              81-frame training clips with their events
    events.json                all dynamic events of the run
    meta.json                  run statistics (appearance, events, behaviour, characters)
    capture_result.json        capture settings, appearance parameters, layout counts
    scene_actors.json          static-mesh inventory of the scene before augmentation
summary_v4.csv / summary_v4.json   statistics for all 100 runs
pairs_v4.json                      same-layout appearance groups and per-pair matching frames
previews/                          report figures (events, appearance strips, characters, night calibration, determinism)
thumbs/                            one thumbnail per run (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-v4"
scene, run = "05_Japanese_Spring_Sanctuary", "L1_night_s543"
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; c["events"] lists events inside the clip

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
meta = [json.loads(f["json"]) for f in clip]                                          # characters, events, ...
act = blocks[s // 4 : s // 4 + 20]                                                   # (20,5) one prompt per latent group

To get the same clip in another appearance, replace night in the run name with another appearance of the same group (for the s43 groups the frames line up exactly).

Capture details

• Unreal Engine 5.8.3, isometric orthographic camera following the player, random camera yaw / pitch / ortho width per episode.
• Offline fixed-timestep simulation at 48 Hz, keeping every 3rd step: 16 fps of game time independent of wall-clock speed. The 8.3 h of data took about 7 h of capture time.
• Each run waits for shader and asset compilation to go idle and warms up before the first saved frame; every frame's labels are checked for invalid pixels.

Known limitations

• Same 10 scenes as v3. No new scenes were generated for v4; all extra variety comes from changes inside these scenes.
• The whitebox is static. It is built at the start of a run and does not include objects added or removed by events, or the shuffled positions of moved props.
• Simple procedural objects. The spawned rocks and props are built from primitive shapes with the scene's materials.
• Scene 03 is still fight-heavy (about 54% of frames), because its boss spawns next to the main route.
• Weak golden hour in scene 09. The cyberpunk scene's shadows do not follow the sun direction, so golden only changes the colour grade there.
• Night brightness varies by scene (mean 14–52 on a 0–255 scale) even with calibration.
• Scene 08 night uses a different recipe. The Gothic quarter's shadowed streets went fully black with the standard night setting (its brightly lit plaza dominated the exposure probes). 08_Gothic_Cathedral_Quarter/L1_night_s843 keeps the lamps at their authored intensity, adds more sky fill and moonlight, and uses a fixed exposure derived from a full-run measurement; the values are in its capture_result.json (appearance).