inouye-lab/StarCraftMotion_sample

StarCraftMotion

StarCraftMotion is a large-scale benchmark for agent simulation under adversarial and partial observability scenarios (built from StarCraft replays). Each example is a fixed-length scenario window (145 frames at 16 FPS, ~9 seconds) containing all unit states, dynamic map layers, and per-player economy time series.

• Total scenarios: 1,000
• Train / Val / Test: 800 / 100 / 100
• Source replays: 64,327 replay-level HDF5 files (Blizzard 3.16.1-Pack_1-fix)
• Maps (ID): Abyssal_Reef_LE, Acolyte_LE, Ascension_to_Aiur_LE, Interloper_LE, Mech_Depot_LE
• Maps (OOD, test only): Catallena_LE_(Void), Odyssey_LE
• Splits are replay-level — windows from the same replay never cross splits.

Why parquet, and how to read

Each row is one scenario. All per-frame / per-unit array columns are stored as typed Arrow list arrays (e.g. LIST<float16>, LIST<bool>). n_timesteps = 145 and n_units varies per scenario (stored per row). The dynamic map layers (map_creep, map_fow_p1, map_fow_p2) are sampled every 16 frames, giving map_T = 10 snapshots per scenario. Spatial dimensions map_H and map_W are stored as explicit scalar columns per row (map-dependent; e.g. Abyssal_Reef_LE is 176 × 200).

import numpy as np
import pyarrow.parquet as pq
from huggingface_hub import hf_hub_download

path = hf_hub_download("inouye-lab/StarCraftMotion_sample", "train/shard_00000.parquet", repo_type="dataset")
row = next(pq.ParquetFile(path).iter_batches(batch_size=1)).to_pylist()[0]

T, N = row["n_timesteps"], row["n_units"]
map_T, map_H, map_W = row["map_T"], row["map_H"], row["map_W"]

coord = np.asarray(row["coordinate"], dtype=np.float16).reshape(T, N, 3)
alive = np.asarray(row["is_alive"],   dtype=bool    ).reshape(T, N)
owner = np.asarray(row["unit_owner"], dtype=np.uint8 ).reshape(N)
utype = np.asarray(row["unit_type"],  dtype=np.uint32).reshape(T, N)
creep = np.asarray(row["map_creep"],  dtype=bool    ).reshape(map_T, map_H, map_W)

Schema

Scalar fields

Field	Type	Description
split	string	train, val, or test
map_name	string	Map name (spaces replaced with _)
replay_hash	string	Hash of the parent SC2Replay file
segment_idx	int32	Index of this 145-frame window inside the parent replay
n_timesteps	int32	Number of frames per row (constant 145 in this release)
n_units	int32	Number of unique unit rows in this scenario (variable)
map_T	int32	Number of map snapshots per row (constant 10 in this release)
map_H	int32	Map grid height in cells (map-dependent)
map_W	int32	Map grid width in cells (map-dependent)
player_1_start_location	list<float32>	Full xyz start location, length 3, for in-game slot 1
player_2_start_location	list<float32>	Full xyz start location, length 3, for in-game slot 2
playable_area	list<int64>	Playable bounds [x0, y0, x1, y1], length 4
chunk_start_frame	int32	Scenario start frame
chunk_end_frame	int32	Scenario end frame
map_frame_start	int32	Starting map-layer frame
map_frame_skip	int32	Map sampling interval, constant 16
current_frame_idx	int32	Current-frame index, constant 16
player_info	string	JSON list with keys player_id (in-game slot 1/2), race_requested, race_actual (0 = NoRace, 1 = Terran, 2 = Zerg, 3 = Protoss, 4 = Random), player_result (1 = Victory, 2 = Defeat, 3 = Tie, 4 = Undecided), player_mmr, player_apm
replay_info	string	JSON object with keys game_duration_loops, game_duration_seconds (float), game_version (string), data_build, base_build

Map data — shape (map_T, map_H, map_W) where map_T = 10

map_H and map_W are map-specific (each StarCraft II ladder map has its own native grid). All three layers below share the same shape per scenario.

Field	dtype
map_creep	bool
map_fow_p1	bool
map_fow_p2	bool

Player economy — shape (145, 2), column 0 = Player 1, column 1 = Player 2

Field	dtype
food_cap	uint8
food_used	uint8
minerals	uint16
vespene	uint16

Per-unit constants — shape (n_units,)

Field	dtype	Description
unit_owner	uint8	1 = P1, 2 = P2, 16 = neutral
unit_tag	uint64	Raw SC2 engine tag (unique per unit instance)

Per-frame, per-unit — shape (145, n_units) unless noted

Field	dtype	Shape	Description
coordinate	float16	(145, n_units, 3)	Native (x, y, z) map coordinates
target_pos	float16	(145, n_units, 2)	Order target ground position
health	float16
health_max	float16
shield	float16		Protoss shield
energy	float16
heading	float16		Facing direction in radians (0 to 2π)
radius	float16		Unit collision radius
build_progress	float16		0.0–1.0
unit_type	uint32		Raw SC2 unit type ID
ability_id	uint32		First order's ability ID
target_id	uint32		Target's row index (0xFFFFFFFF = no target)
mineral_contents	uint16		Remaining minerals (mineral fields)
vespene_contents	uint16		Remaining vespene (geysers)
is_alive	bool
is_burrowed	bool		Zerg burrowed
is_carried	bool		Inside a transport
is_flying	bool		Air unit / lifted building
visible_status	uint8		Combined P1/P2 visibility (see below)

visible_status = p1_state * 3 + p2_state, with each state in {0 = unseen, 1 = snapshot, 2 = visible}. Examples: 8 = visible to both, 6 = visible to P1 only, 2 = visible to P2 only.

Action labels

The ability_id column stores the raw SC2 ability ID as uint32 (e.g. MOVE = 16, ATTACK_ATTACK = 23, HARVEST_GATHER_DRONE = 1183, ability_id == 0 means the unit has no active order). It is not class-indexed.

For action prediction tasks we provide an 11-class coarse mapping in the source repository at utils/coarse_action_mapping.py.

Label	Name	Description
0	NO_OP	ability_id == 0; unit idle
1	MOVE	move, patrol, hold position, stop, smart (right-click)
2	ATTACK	attack, attack-move, attack building
3	HARVEST	gather resources, return cargo
4	TRAIN	produce units from buildings / larvae / warp-in
5	BUILD	construct structures, add-ons, creep tumors
6	RESEARCH	upgrades and tech research
7	MORPH	unit/structure transformation (siege, archon, lair, etc.)
8	EFFECT	combat abilities, spells, auto-cast effects
9	TRANSPORT	load, unload, lift off, land
10	BURROW	burrow down / burrow up (Zerg)
255	UNKNOWN	unmapped or cosmetic

Sources for the mapping:

• Blizzard s2client-api ABILITY_ID enum: https://blizzard.github.io/s2client-api/sc2__typeenums_8h.html
• Blizzard s2client-proto stableid.json: https://github.com/Blizzard/s2client-proto/blob/master/stableid.json

Coverage on the released split is 100% of all action occurrences (every ability_id either matches a Blizzard enum prefix, is one of 10 explicit stableid.json overrides, or is 0 / falls into UNKNOWN).

Applying the mapping

import numpy as np
from utils.coarse_action_mapping import ABILITY_ID_TO_COARSE_ACTION

T, N = row["n_timesteps"], row["n_units"]
ability_id = np.asarray(row["ability_id"], dtype=np.uint32).reshape(T, N)

# Vectorized lookup via a dense uint8 table.
max_id = max(ABILITY_ID_TO_COARSE_ACTION) + 1
lut = np.full(max_id, 255, dtype=np.uint8)
for aid, label in ABILITY_ID_TO_COARSE_ACTION.items():
    lut[aid] = label

coarse = np.where(ability_id < max_id, lut[np.clip(ability_id, 0, max_id - 1)], 255)

Pipeline summary

1. Replay extraction (extract_replay_level.py): three SC2 engine passes (omniscient + per-player FOW) into one HDF5 per replay, preserving native coordinates, raw SC2 unit/ability IDs, and per-player visibility.
2. Scenario windowing (split_scenarios.py): chunk into 145-frame windows at 16 FPS (1 s history + current + 8 s future). Drops replays with duration < 120 s or either player at APM < 1.
3. Replay-level split (create_dataset_split.py): 80/10/10 train/val/test over ID maps; OOD maps go to test only. Keeps 10% of each replay's windows.
4. Interaction-biased window sampling: drop windows with no mutually observable units, then sample 10% of each replay's candidate windows with higher probability for many mutually visible units or frequent visibility-status changes. Window sampling weight is log(1 + mutual_unit_sum) + log(1 + transition_cnt); zero-score windows are excluded.

Dataset statistics

Mingyu Kim's sample_convert_to_parquet.py uses seed 42, stratified by split and map, to select 800 train, 100 validation and 100 test scenarios; all seven maps are represented in test.

Player-unit counts (units with owner != 16)

Split	Mean	Std	Min	P25	Median	P75	Max
Train	201.49	107.92	19	112	186	280.25	559
Val	199.96	118.06	35	100.75	181	291.5	477
Test	200.25	117.61	43	100.75	172	294.5	526

Race matchups

Split	PvP	PvT	PvZ	TvT	TvZ	ZvZ
Train	59	201	156	115	205	64
Val	6	16	23	14	33	8
Test	7	17	21	14	32	9

Mutual visibility (units with visible_status == 8 and is_alive)

Split	Mean mutually-visible units / frame
Train	28.67
Val	27.79
Test	26.66

Intended use

• Multi-agent simulation under adversarial partial observability.
• Benchmarks for fog-of-war handling, ID vs OOD-map generalization, and interaction-heavy scenes.

Limitations and ethical considerations

• Replay provenance: raw replays come from Blizzard's 3.16.1-Pack_1-fix distribution. Per-replay curation, demographics of players, and any prior filtering performed by Blizzard are not documented.
• MMR caveat: player_info.player_mmr values include negatives (down to -36400) for some replays. League-tier bucketing should be recomputed rather than relied upon naively.
• Single game version: all replays are SC2 build 3.16.1; balance and meta-game differ from current ladder versions.
• No personally identifying content is included beyond what Blizzard publishes in replay packs. Player names are not surfaced as columns.
• Game-balance / strategic bias: the corpus is whatever Blizzard released in the pack and is not a uniform sample of competitive play.

License

The released parquet artifacts are licensed under Creative Commons Attribution-NonCommercial 4.0 International (CC-BY-NC-4.0) (SPDX: CC-BY-NC-4.0).

The released parquet files are derivative ML features (float16 unit trajectories, fog-of-war and creep masks, per-player economy time series, and raw SC2 unit/ability identifiers) extracted from StarCraft II replays. The dataset does not redistribute raw .SC2Replay files, SC2 game maps, or any portion of the StarCraft II Software. Use of the underlying StarCraft II replays and the SC2 engine is separately governed by Blizzard's AI and Machine Learning License; that license explicitly permits use of derived ML data for personal or internal research and development.

Authors

• Yi-Chung Chen — Purdue University
• Mingyu Kim — Purdue University
• Ruqi Bai — Purdue University
• James Zachary Hare — DEVCOM Army Research Laboratory
• Jing Gao — Purdue University
• David I. Inouye — Purdue University

Citation

@inproceedings{chen2026starcraftmotion,
  title = {StarCraft Motion: A Dataset for Agent Simulation in Adversarial and Partially Observable Scenarios},
  author = {Yi-Chung Chen and Mingyu Kim and Ruqi Bai and James Zachary Hare and Jing Gao and David I. Inouye},
  booktitle = {NeurIPS 2026 Evaluations and Datasets Track},
  year = {2026}
}

Underlying replays:

@misc{blizzard_sc2_replaypacks,
  title  = {StarCraft II Replay Packs (3.16.1-Pack\_1-fix)},
  author = {{Blizzard Entertainment}},
  howpublished = {\url{https://blzdistsc2-a.akamaihd.net/ReplayPacks/3.16.1-Pack_1-fix.zip}}
}

Acknowledgments

Built on top of DeepMind's pysc2 and Blizzard's StarCraft II AI/ML infrastructure.