Datasets:

inouye-lab
/

StarCraftMotion_sample

---
license: cc-by-nc-4.0
pretty_name: StarCraftMotion
language:
- en
size_categories:
- 1K<n<10K
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.

- **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).

```python
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
```python
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)**](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.
## 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
```bibtex
@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:
```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.

	---
	license: cc-by-nc-4.0
	pretty_name: StarCraftMotion
	language:
	- en
	size_categories:
	- 1K<n<10K
	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.

	- 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).

	```python
	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

	```python
	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)](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.


	## 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

	```bibtex
	@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:

	```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.