| --- |
| license: cc-by-nc-4.0 |
| pretty_name: StarCraftMotion |
| language: |
| - en |
| size_categories: |
| - 100K<n<1M |
| task_categories: |
| - time-series-forecasting |
| - other |
| tags: |
| - starcraft |
| - multi-agent |
| - agent-simulation |
| - partial-observability |
| - benchmark |
| configs: |
| - config_name: default |
| data_files: |
| - split: train |
| path: train/*.parquet |
| - split: validation |
| path: validation/*.parquet |
| - split: test |
| path: test/*.parquet |
| --- |
| |
| # 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. |
|
|
| The released split is **adversarial**: scenarios are subsampled to |
| overweight interaction-heavy windows (mutual-visibility and inter-player |
| transitions), making it a stress test for multi-agent prediction under |
| partial observability. |
|
|
| - **Total scenarios:** 469,187 |
| - **Train / Val / Test:** 362,075 / 45,121 / 61,991 |
| - **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 `large_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). |
| |
| ```python |
| import numpy as np |
| from datasets import load_dataset |
| |
| ds = load_dataset("blind-review-data/StarCraftMotion", split="train", streaming=True) |
| row = next(iter(ds)) |
| |
| 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) | |
| |
| #### 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 |
| [`sc2sensor/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 |
| |
| ```python |
| import numpy as np |
| from sc2sensor.utils.coarse_action_mapping import ABILITY_ID_TO_COARSE_ACTION |
| |
| T, N = row["n_timesteps"], row["n_units"] |
| ability_id = np.frombuffer(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. **Adversarial weighting**: window sampling weight is |
| `log(1 + mutual_unit_sum) + log(1 + transition_cnt)`; zero-score windows |
| are excluded. |
|
|
| ## Dataset statistics |
|
|
| ### Player-unit counts (units with `owner != 16`) |
|
|
| | Split | Mean | Std | Min | P25 | Median | P75 | Max | |
| |-------|-------:|-------:|----:|----:|-------:|----:|----:| |
| | Train | 204.56 | 113.06 | 11 | 109 | 189 | 284 | 921 | |
| | Val | 203.56 | 112.51 | 18 | 109 | 188 | 282 | 689 | |
| | Test | 202.78 | 111.70 | 13 | 107 | 189 | 281 | 779 | |
|
|
| ### Race matchups |
|
|
| | Split | PvP | PvT | PvZ | TvT | TvZ | ZvZ | |
| |-------|-------:|-------:|-------:|-------:|--------:|-------:| |
| | Train | 23,322 | 82,819 | 66,139 | 54,819 | 104,780 | 30,196 | |
| | Val | 3,037 | 9,978 | 8,514 | 6,853 | 13,326 | 3,413 | |
| | Test | 4,112 | 13,927 | 10,883 | 9,536 | 18,531 | 5,002 | |
|
|
| ### Mutual visibility (units with `visible_status == 8` and `is_alive`) |
|
|
| | Split | Mean mutually-visible units / frame | |
| |-------|------------------------------------:| |
| | Train | 23.56 | |
| | Val | 23.40 | |
| | Test | 23.43 | |
|
|
| ## 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:** raw MMR values include sentinel-like 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)**](https://spdx.org/licenses/CC-BY-NC-4.0.html) |
| (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](https://blzdistsc2-a.akamaihd.net/AI_AND_MACHINE_LEARNING_LICENSE.html); |
| that license explicitly permits use of derived ML data for personal or |
| internal research and development. |
|
|
|
|
| ## Citation |
|
|
| Underlying replays: |
|
|
| ```bibtex |
| @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. |
|
|
