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