AoE2 Dataset — SAGE

This repository contains two Age of Empires II: Definitive Edition match datasets, built as part of the SAGE research project. The data is rich but not polished for general consumption: it was designed around a specific set of research questions, and using it for anything else will require some work on your end. That said, the raw material is genuinely useful, time-series snapshots of real competitive games at minute and second resolution, with entity positions, resource states, player commands, and combat events all aligned on the same timeline.

If you are doing game analytics, strategy modelling, time-series classification, or sports science research and want real multi-agent sequential decision data, this dataset is a solid starting point. The schema is documented in full below.

Heads up: This dataset is relational. The windowed files (players, entities, masters, research) share a sage:windowId key; event files (events, commands) use world timestamps. They all live in the same folder and are designed to be joined. A task-specific denormalization step is expected for most ML pipelines. Task-specific adaptations are encouraged, please keep the data notices and attribution intact in any derived work.

Overview

Two datasets:

1. kotd4: Recorded games from the King of the Desert 4 tournament. Used for the original SAGE project. Total 179 games.
2. may2026: A newer, larger dataset from 1v1 Random Map ladder games from May 2026. Total TBD (still processing).

Each dataset contains different data views of the same matches, each optimised for different purposes:

1. .aoe2records: Native game file. Contains starting conditions and the commands issued during the game. These are game-version dependent.
2. .caderecs: Native CaptureAge files that can be opened directly from the CaptureAge client. These are virtually game-version independent.
3. Arrow .zips: Memory-optimised data frames at different window snapshot rates (60 and 1 seconds). Used for the original SAGE project. This uses the IPC format, which best mimics the limitations of the original research.
4. Parquet .zips: Storage-optimised data frames at the same window snapshot rates (60, 1 seconds), converted from the Arrow files.

More details below. sample-unzipped contains a single unzipped example of a recorded game and all related features.

Age of Empires as a Case Study

We believe that Age of Empires is a game uniquely suited for scientific research, due to community and official efforts on data analysis. Moreover, the game's rules are simple and derived from clear diegetic principles that can be understood without deep domain knowledge (e.g. Spearmen counter mounted Knights).

---

AoE2 Record

The original recorded game file as produced by the game engine.

Note on compatibility: Running older recorded games in their original version is possible by restoring game versions via Steam depots. This has led to mixed results. If there is no need to run the recorded games in the game engine itself, using .caderec files in CaptureAge is highly recommended, as these are virtually version-independent recreations at near-perfect resolution.

---

CADE Recs

.caderec files are essentially ZIP archives containing metadata and the internal CaptureAge .carz file. The original .carz files used to produce the .caderecs were not kept separately and should be extracted from the .caderecs if needed.

A random sample was run in CaptureAge end-to-end, and all sampled files successfully ran to the match's conclusion.

Notes and Limitations

There are some notes regarding the data that users should be aware of when making assumptions. For most use cases this data will provide a strong basis.

• Matches are semi-randomly selected and results may be biased by map distribution, due to player preferences.
• The official AoE2 API does not retain all recorded games indefinitely; only games from the active patch at the time of collection were sampled, and not all were still available on the server.
• Since the SAGE project was long-running, it was not fully updated throughout. Newer game mechanics may not be properly captured in the .caderecs and are excluded from the Arrow and Parquet exports.
• Some recordings failed to parse for a variety of reasons. An effort was made to maximise coverage, but not all files could be recovered. The estimated .aoe2record → .caderec → Arrow success rate is roughly 80–90%. Incompatibilities may be feature-consistent and could introduce bias depending on the study.
• All games were validated to have a declared winner at the end. Very short games where a winner was declared early were kept intentionally, but may warrant scrutiny depending on the goals of a specific study. These games are not included in the train, eval or test sets.
  • For KotD4, this includes "restores" where a game was unexpectedly terminated and then restored from the last backup checkpoint.
• If the metadata in the .caderecs (which contains: players, winner, map, civ IDs, and game length) is insufficient, the Arrow or Parquet data alongside descriptor.json can help validate suitability for a specific goal.
• Despite being a newer feature of CaptureAge, the KotD4 .caderec files are present. They lack some CA:DE features due to being recorded earlier, notably fast-forward and some statistics.
• Filenames (may2026): Each file is named PlayerName1_(Civilization1)_Rating1_vs_PlayerName2_(Civilization2)_Rating2_UniqueGameId. The player and game ID can be used to query the official API to expand and validate metadata.
• FoW and Command files were not used in the original SAGE project and are newly added in may2026. Command issuer attribution is not always consistent for the small kotd4 dataset; ownership of the issued targets can serve as a fallback for most cases, with the exception of monk conversions. FoW has not been validated beyond visual inspection.
• The sage:ductType column in entities.arrow is optional for most analyses. It records the lifecycle state of each entity within the snapshot window (Created, Updated, Deleted, Transient) and is primarily useful for reconstructing what happened to an entity between snapshot times.

Data Windows

KotD4

All recorded games as played. These were kindly supplied by DonDinardoni with permission from MembTV in 2021.

• Dates: 2021-11-18 to 2021-12-12 See tournament schedule
• Game version: 56005
• The start time for this dataset may miss some seconds at the start. This was a limitation at the time of recording.

May 2026

Ranked 1v1 Random Map ladder games collected in May 2026.

• Dates: May 2026
• Game version: 175278
• The start time for this dataset is consistently from 104 ms from the start of the game, capturing virtually all data from end to end.

---

Legal and Attribution

Microsoft Game Content

Age of Empires II © Microsoft Corporation. The game strings and unit metadata contained within strings.arrow and strings.parquet were extracted under Microsoft's "Game Content Usage Rules" using assets from Age of Empires II, and are not endorsed by or affiliated with Microsoft. Official rules can be found at https://www.xbox.com/en-us/developers/rules.

Derived Data

The data derived from .aoe2record files consists of player-generated inputs, match telemetry, and mathematical facts parsed from user-submitted recorded game files of Age of Empires II. This dataset is an independent community project. It is not affiliated with, sponsored by, or endorsed by Microsoft Corporation or World's Edge.

The recorded game files themselves were retrieved via the official AoE2 match history API. Use of this data remains subject to the applicable Microsoft Developer and Service Agreement terms: https://learn.microsoft.com/en-us/legal/mdsa

All files were processed with written permission from CaptureAge and verbal permission from a Microsoft representative.

License

The non-string Arrow, Parquet, and .caderec components of this dataset are released under the Apache License 2.0. The game string assets (strings.arrow, strings.parquet) and the original .aoe2record files are subject to their respective terms described above.

Citation

If you use this dataset, please cite the accompanying thesis:

@mastersthesis{VanWingerden2026,
  month    = {June},
  author   = {van Wingerden, S.},
  year     = {2026},
  school   = {University of Twente},
  address  = {Enschede},
  type     = {Thesis},
  title    = {One Thousand and One Tales: Automated Age of Empires {II} eSports Reports from Raw Real-time Game Data},
  url      = {https://purl.utwente.nl/essays/109934},
}

@dataset{VanWingerden2026sage,
  author    = {van Wingerden, S.},
  title     = {{SAGE} Dataset: Age of Empires {II} {DE} Match Analytics},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/Siewart/sage},
}

APA: van Wingerden, S. (2026). One Thousand and One Tales: Automated Age of Empires II eSports Reports from Raw Real-time Game Data (Master's thesis, University of Twente, Enschede). https://purl.utwente.nl/essays/109934

---

Arrow / Parquet Schema

All Arrow files use the Apache Arrow IPC streaming format. Parquet files are converted 1:1 from Arrow with schema parity validated after each conversion. Each game folder contains the following files.

Special column name prefixes: sage: fields are SAGE-internal metadata columns present in all files where noted.

---

players.arrow / players.parquet

One row per player per window. Tracks per-player state at each snapshot.

Column	Type	Nullable	Description
sage:windowId	Uint32	No	Window frame index
id	Int8	No	In-game player id (1–8, 0 for Gaia/Nature)
color	Int32	No	Chosen color ID
name	Utf8	No	Player name
civilization	Uint32	No	Civilisation ID
victoryPoints	Int32	No	Victory points
startX	Float32	No	Starting town centre X
startY	Float32	No	Starting town centre Y
resigned	Bool	No	Whether the player has resigned
gameStatus	Uint8	No	Game status code (2 = active winner declared)
humanity	Uint8	Yes	Slot type
resolvedTeamId	Int8	Yes	Resolved team index
profileId	Utf8	Yes	Relic profile ID (stored as string)
handicap	Int32	Yes	Handicap setting
rmElo	Int32	Yes	Random Map ELO at match time
dmElo	Int32	Yes	Death Match ELO at match time
food	Float32	Yes	Current food
wood	Float32	Yes	Current wood
stone	Float32	Yes	Current stone
gold	Float32	Yes	Current gold
maxPop	Float32	Yes	Population cap
currentAge	Float32	Yes	Current age (0=Dark ... 3=Imperial)
population	Float32	Yes	Current population
razings	Float32	Yes	Buildings razed
foodTotal	Float32	Yes	Total food gathered
woodTotal	Float32	Yes	Total wood gathered
stoneTotal	Float32	Yes	Total stone gathered
goldTotal	Float32	Yes	Total gold gathered
relicGold	Float32	Yes	Gold from relics
relicFood	Float32	Yes	Food from relics
relicWood	Float32	Yes	Wood from relics
relicStone	Float32	Yes	Stone from relics
civilianPop	Float32	Yes	Civilian population
militaryPop	Float32	Yes	Military population

---

entities.arrow / entities.parquet

One row per entity per window. Covers all in-game objects (units, buildings, missiles, doppelgangers).

DUCT columns (present on all entity rows):

Column	Type	Nullable	Description
sage:modelType	Dictionary(Utf8, Uint8)	No	Entity subtype: Entity, DoppleEntity, ActionEntity, CombatEntity, MissileEntity, BuildingEntity
sage:windowId	Uint32	No	Window frame index
sage:ductType	Dictionary(Utf8, Int8)	No	Lifecycle state: Deleted, Updated (default), Created, Transient
sage:creationTime	Uint32	Yes	World time of creation (ms)
sage:deletionTime	Uint32	Yes	World time of deletion (ms)

Core fields:

Column	Type	Nullable	Description
id	Int32	No	Entity ID
masterId	Int16	No	Master (prototype) ID
refMasterId	Int16	No	Normalized master ID (e.g., a male Lumberjack and a female Fisher have the Villager id)
ownerId	Uint8	No	Owning player
worldX	Float32	No	X position
worldY	Float32	No	Y position
worldZ	Float32	No	Z position
heldAttributeAmount	Float32	No	Amount of held resource/attribute
heldAttributeType	Int16	No	Type of held resource/attribute
state	Uint8	No	Entity state
doppleFlag	Bool	No	Whether entity is a fog-of-war doppelganger
type	Uint8	No	Object type
hp	Float32	No	Current hit points
insideObjId	Int32	No	ID of garrisoning object (-1 if none)
groupId	Int32	No	Formation group ID
workerNum	Int32	No	Number of assigned workers

DoppleEntity fields (nullable):

Column	Type	Description
doppledObjectId	Int32	ID of the real entity being doppelganged (last seen copy in FoW)
doppledPlayerId	Int8	Owner of the real entity

ActionEntity fields (nullable):

Column	Type	Description
currentAction	Struct (see Action)	Current unit action
formationType	Uint8	Formation type
attackStance	Uint8	Attack stance

MissileEntity fields (nullable):

Column	Type	Description
firedFromId	Int32	ID of entity that fired this missile

BuildingEntity fields (nullable):

Column	Type	Description
linkedOwnerId	Int32	Linked owner entity ID
currentProductionQueueAction	Struct (see Action)	Active production action
gatherPointX/Y/Z	Float32	Gather/rally point coordinates
gatherPointTargetId	Int32	Gather point target entity ID
buildPts	Float32	Construction progress
originalOwnerId	Int8	Original owner before capture
built	Bool	Whether construction is complete
relicCount	Int32	Relics stored
productionQueue	List<ProductionQueueRecord>	Production queue
lastSeen	List<Uint32>	Per-player last-seen world time (ms), index corresponds to player id

---

masters.arrow / masters.parquet

Master (prototype) data per player per window, unit/building stat definitions as seen by each player including any tech upgrades applied.

Column	Type	Nullable	Description
sage:windowId	Uint32	No	Window frame index
sage:modelType	Dictionary(Utf8, Uint8)	No	MasterEntity, MasterMovingEntity, MasterActionEntity, MasterCombatEntity, MasterMissileEntity, MasterBuildingEntity
id	Int16	No	Master ID; negative values indicate synthetic master IDs (e.g. a converted unit retains its original stats under a new ID)
playerId	Uint8	No	Owning player id
type	Uint8	No	Object type
stringId	Int32	No	String table ID (resolve via strings.arrow)
objectGroup	Int16	No	Object class/group
hp	Int16	No	Base hit points
objCapacity	Uint8	No	Garrison/storage capacity
radiusX/Y/Z	Float32	No	Collision radius
available	Bool	No	Whether the unit is available to train
disabled	Bool	No	Whether the unit is disabled
constructionRadiusX/Y	Float32	No	Construction placement radius
resourceGroup	Uint8	No	Resource gathering group
attributesHeld	List<AttributeValue>	No	Held resource/attribute definitions
speed	Float32	Yes	Movement speed (ActionEntity only)
baseArmor	Int16	Yes	Base armor value (CombatEntity only)
armor	List<ArmorWeaponInfo>	Yes	Armor class entries
weapon	List<ArmorWeaponInfo>	Yes	Weapon entries
weaponRange	Float32	Yes	Attack range
areaDamage	Float32	Yes	Area-of-effect damage
speedOfAttack	Float32	Yes	Attack speed
combatAbility	Uint8	Yes	Combat ability flags
origArmor/Weapon/WeaponRange/SpeedOfAttack	various	Yes	Pre-upgrade baseline values
buildPtsRequired	Float32	Yes	Construction points required
minimumWeaponRange	Float32	Yes	Minimum attack range
buildInventory	List<AttributeValue>	Yes	Build cost resource list

---

research.arrow / research.parquet

One row per technology per player per window. Only technologies not in the CantResearch state are emitted.

Column	Type	Nullable	Description
sage:windowId	Uint32	No	Window frame index
playerId	Int8	No	Player id
researchId	Int16	No	Technology ID
stringId	Int32	Yes	String table ID
researchDone	Float32	No	Research progress (0.0–1.0)
state	Uint8	No	Research state enum
buildObjId	Int16	Yes	Building researching this tech
timesResearched	Int16	Yes	Times researched (for repeatable techs)
allowMultipleResearch	Bool	Yes	Whether multiple researches are allowed

---

world.arrow / world.parquet

One row per window. Global world state.

Column	Type	Nullable	Description
sage:windowId	Uint32	No	Window frame index
time	Uint32	No	World time (ms)
woodPrice	Float32	No	Current market wood price
foodPrice	Float32	No	Current market food price
stonePrice	Float32	No	Current market stone price

---

events.arrow / events.parquet

One row per discrete game event. Not windowed, events have exact world timestamps.

Column	Type	Nullable	Description
sage:modelType	Dictionary(Utf8, Uint8)	No	Event type: damage, death, marketTransaction, techStatus, monkConversion, garrison, lifeCycle, tribute, victoryCountdown
worldTime	Uint32	No	Event timestamp (ms)
worldX/Y/Z	Float32	Yes	World position
objectEntity	Int32	Yes	Primary entity involved
subjectEntity	Int32	Yes	Secondary entity involved
objectPlayerId	Uint8	Yes	Owner of object entity
subjectPlayerId	Uint8	Yes	Owner of subject entity
resourceType	Uint8	Yes	Resource type (tribute/market)
resourceAmount	Uint16	Yes	Resource amount
goldAmount	Uint16	Yes	Gold amount (market transactions)
techId	Uint16	Yes	Technology ID (techStatus events)
heresyActivated	Bool	Yes	Whether heresy triggered on conversion
remainingTime	Uint32	Yes	Countdown remaining (victoryCountdown)
tag	Dictionary(Utf8, Uint8)	Yes	Sub-type tag: researching, completed, canceled, forceCanceled, garrisoned, ungarrisoned, created, constructed, underConstruction, died, wonderStarted, wonderCompleted, wonderDestroyed, artifactsHeld, artifactsLost, ruinsHeld, ruinsLost

---

settings.arrow / settings.parquet

Single-row file. Game-level metadata.

Column	Type	Description
mapWidth	Uint16	Map width in tiles
mapHeight	Uint16	Map height in tiles
mapName	Utf8	Resolved map name

---

strings.arrow / strings.parquet

String table extracted from the game installation. Used to resolve stringId references in masters and research.

Column	Type	Nullable	Description
id	Int32	No	String ID
string	Utf8	Yes	Localised string value

Note: These files are derived from Microsoft game assets and are subject to the Game Content Usage Rules described in the Legal section above.

---

map.arrow / map.parquet

Static single-snapshot file written once per game. Contains terrain and elevation for every tile. Does not carry a sage:windowId, it reflects the initial map state.

Column	Type	Nullable	Description
x	Int32	No	Tile X coordinate
y	Int32	No	Tile Y coordinate
elevationLevel	Uint8	No	Tile elevation level
terrainType	Uint8	No	Terrain type ID

---

fow.arrow / fow.parquet

One row per tile per window snapshot. Captures fog-of-war visibility state and terrain at each sampled point in time. Rows are only emitted for tiles present in the game's unifiedVisibleMap.

Note: FoW has not been validated beyond visual inspection. Visibility correctness may vary.

Column	Type	Nullable	Description
time	Uint32	No	World time (ms) of the snapshot
x	Int32	No	Tile X coordinate
y	Int32	No	Tile Y coordinate
visibilityMask	Uint32	No	Bitmask of player ids that can see this tile
elevationLevel	Uint8	No	Tile elevation level at this time
terrainType	Uint8	No	Terrain type ID at this time

The visibilityMask is a bitfield, bit i set means player id i has (partial) visibility of the tile at this snapshot.

---

commands.arrow / commands.parquet

One row per issued game command. Not windowed, commands carry exact world timestamps. Uses a wide denormalized schema: most columns are nullable and only populated for the command types that use them.

Note: Command issuer attribution is not always consistent in the kotd4 dataset; some commands do not reliably identify their issuing player. Validation via entity ownership is recommended where accuracy matters.

Combined commands: The game engine emits one townbell command per affected building, but this represents a single human action (pressing the Town Bell button). SAGE collapses all gobacktowork and cancelbuild commands with the same issuer and world timestamp into a single row; unitIds on that row contains all building IDs that received the command.

Column	Type	Nullable	Description
sage:modelType	Dictionary(Utf8, Uint8)	No	Command type (see list below)
worldTime	Uint32	No	Command timestamp (ms)
issuer	Uint32	No	Issuing player ID
unitIds	List<Int32>	Yes	Unit(s) the command was issued to
targetIds	List<Int32>	Yes	Target entity ID(s)
location1X/Y/Z	Float32	Yes	Primary target location
location2X/Y/Z	Float32	Yes	Secondary location (e.g. wall endpoint)
waypoints	List<Float32>	Yes	Waypoint list, interleaved X, Y, Z triplets
extend	Bool	Yes	Extend/queue flag
instant	Bool	Yes	Immediate execution flag
humanOrder	Bool	Yes	Whether issued by a human (vs AI)
controlHeld	Bool	Yes	Control key held
reset	Bool	Yes	Reset existing waypoints
inFront	Bool	Yes	Insert at front of queue
dropped	Bool	Yes	Player dropped (resign)
exitAfterSave	Bool	Yes	Exit after multiplayer save
activateFlag	Int32	Yes	Activation flag (e.g. town bell)
playerId1	Int32	Yes	Primary player ID
playerId2	Int32	Yes	Secondary player ID (e.g. tribute target)
objCategory	Int32	Yes	Object category
objId	Int32	Yes	Object / train ID
masterId	Int32	Yes	Master/prototype ID (includes unit type, unload unit type)
uniqueId	Int32	Yes	Unique object ID
formationType	Int32	Yes	Formation type
triggerId	Int32	Yes	Scenario trigger ID
action	Int32	Yes	Action type
orderType	Int32	Yes	AI order type
orderPriority	Int32	Yes	AI order priority
state	Int32	Yes	Unit/gather/gate state
techId	Int32	Yes	Technology ID
attrIds	List<Int32>	Yes	Attribute type IDs
attrAmounts	List<Float32>	Yes	Attribute amounts
attrCosts	List<Float32>	Yes	Attribute costs
gameCommandId	Int32	Yes	Game sub-command ID
var1	Int32	Yes	Generic variable (param / value / flare flags depending on command)
var2	Int32	Yes	Generic variable
var3	Float32	Yes	Generic variable
var4	Int32	Yes	Generic variable
frame	Int32	Yes	Sprite frame (build)
spriteOverrideId	Int32	Yes	Sprite override ID
signalId	Int32	Yes	AI signal ID
effectType	Int32	Yes	AI effect type
unitorTechId	Int32	Yes	Unit or technology ID (AI effect)
attributeType	Int32	Yes	Attribute type (AI effect)
lotCount	Int32	Yes	Market lot count
unloadFlag	Int32	Yes	Unload mode
range	Float32	Yes	AI order range
sequence	Int32	Yes	Diplomacy sequence
status	Int32	Yes	Diplomacy status
declare	Int32	Yes	Diplomacy declare flag
diplomacy	Int32	Yes	Diplomacy value
intelligence	Int32	Yes	Intelligence sharing flag
trade	Int32	Yes	Trade flag
demand	Int32	Yes	Demand value
gold	Int32	Yes	Gold amount (diplomacy)
message	Utf8	Yes	Diplomacy message
newName	Utf8	Yes	New player name (changeplayername)
commandId	Int32	Yes	Raw command ID (unknowncommand fallback)

Command types (sage:modelType values): notset, interact, stop, work, move, create, addattribute, aiorder, resign, addwaypoint, pause, groupwaypoint, groupaiorder, unitaistate, guard, follow, patrol, scout, formformation, wheelformation, aboutfaceformation, multiplayersave, groupmultiwaypoints, chapter, attackmove, attackmovetarget, retreat, unittypeaistate, autoscout, stopall, moretechs, transformobject, trigger, transformobjects, make, research, build, game, explore, buildwall, cancelbuild, attackground, giveattribute2, tradeattribute, repair, unload, gate, flare, special, unitorder, diplomacy, queue, setgatherpoint, setretreatpoint, sellcommodity, buycommodity, unittransform, droprelic, townbell, gobacktowork, multiqueue, setgatherstate, deleteobjects, resetbuildings, multigate, gobacktowork2, changeplayername, sendaisignal, aieffectamount, aieffectpercent, giveattributes, unknowncommand

---

Embedded Structs

Action (embedded in entities)

Field	Type	Nullable	Description
sage:modelType	Dictionary(Utf8, Uint8)	No	Action, MakeObjectAction, MakeTechAction, GatherAction, HuntAction, ConvertAction, WonderAction, PackAction, UnpackAction, MakeAction
type	Int16	No	Action type
state	Int8	No	Action state
targetId	Int32	No	Target entity ID
targetX/Y/Z	Float32	No	Target position
timer	Float32	No	Action timer
objId	Int16	Yes	Object being produced (MakeObjectAction)
workDone	Float32	Yes	Work progress (MakeObjectAction)
techId	Int16	Yes	Technology ID (MakeTechAction)
researchProgress	Float32	Yes	Research progress (MakeTechAction)
startTime	Float32	Yes	Research start time (MakeTechAction)
targetType	Int32	Yes	Target resource type (GatherAction / HuntAction)
wasSameOwner	Bool	Yes	Pre-conversion same owner flag (ConvertAction)
requiredRange	Float32	Yes	Required conversion range (ConvertAction)
totalTimer	Float32	Yes	Total conversion timer (ConvertAction)
taskWorkVal1/2	Float32	Yes	Task work values (ConvertAction)
wonderTime	Float32	Yes	Wonder action timer (WonderAction)

ProductionQueueRecord (embedded in entities.productionQueue)

One entry per item currently queued in a building's production queue.

Field	Type	Description
unitId	Int16	Master ID of the unit being produced (-1 if none)
refUnitId	Int16	Canonical reference master ID
techId	Int16	Technology ID if researching (-1 if none)
unitCount	Int16	Number of units queued

---

AttributeValue (embedded in masters.attributesHeld, masters.buildInventory)

A resource or attribute type/amount pair.

Field	Type	Description
type	Int16	Attribute type ID
amount	Float32	Attribute amount
flag	Uint8	Attribute flag

---

ArmorWeaponInfo (embedded in masters.armor, masters.weapon)

A single armor class or weapon attack entry. Armor and weapon interactions in AoE2 are class-based, each entry represents one class pairing.

Field	Type	Description
type	Int16	Armor/weapon class type ID
value	Int16	Armor/attack value for this class

---

descriptor.json

The descriptor is the index file for a game folder. It catalogs all Arrow files, categorises them by access pattern, and provides the window-to-time mapping needed to interpret sage:windowId values.

Cross-file alignment: All windowed files in a game folder share the same sage:windowId space. Window i in players.arrow, entities.arrow, masters.arrow, and research.arrow all refer to the same time slice. The exact in-game time boundaries for each window are given by descriptor.json → metadata.binTimes[i], as [startMs, endMs]. Use binTimes to align windowed data with event-based files (events.arrow, commands.arrow) which use raw worldTime timestamps instead of window IDs.

Top-level fields

Field	Description
name	Full base filename of the game (matches the folder name)
dictionaries	Files used as shared lookup tables (currently strings.arrow)
windowed	Files that carry a sage:windowId column, one row per entity/player/etc. per window
series	Event-based files with exact world timestamps but no window ID (events, commands)
records	Single-snapshot files written once per game (settings, map)
metadata	Game-level constants and the window time index

metadata

Field	Description
civStringIdOffset	Add to a civilization ID from players.arrow to obtain its strings.arrow lookup ID
colorStringIdOffset	Add to a color ID from players.arrow to obtain its strings.arrow lookup ID
binTimes	Array of [startMs, endMs] pairs indexed by sage:windowId

binTimes

binTimes[i] gives the in-game time range (milliseconds) covered by window i. The index directly corresponds to sage:windowId values in all windowed files.

"binTimes": [
  [104,   60008],   // window 0: 104 ms → 60008 ms
  [60021, 120016],  // window 1: 60021 ms → 120016 ms
  ...
  [2340399, 2370249] // last window: shorter, game ended mid-window
]

Key properties:

• Start time (binTimes[i][0]): the world time of the first game tick captured in this window
• End time (binTimes[i][1]): the world time of the last game tick captured, not inclusive of the next window's start
• Gaps are normal: end of window i and start of window i+1 are not contiguous, the gap reflects ticks between snapshot boundaries
• Last window is shorter: the final entry covers the remaining ticks to the end of the game and will typically be less than the configured bin width
• lastSeen in entities.arrow stores game time values in ms (world.time), use binTimes to map them back to a window index if needed

---

index.json

A dataset-level index of all processed games. Useful for filtering and selecting games without reading individual game folders. Companion split files index_train.jsonl, index_validation.jsonl, and index_test.jsonl are provided alongside this file. For kotd4 partial and restored games (6 files across 3 matches) are excluded from splits ("split": null) but retained in index.json for completeness.

Top-level fields

Field	Description
dataset	Dataset identifier (kotd4 or may2026)
generatedAt	ISO 8601 timestamp of when the index was generated
gameCount	Total number of games in the index
games	Array of game entries (see below)

Game entry fields

Field	Type	Description
gameName	string	Base filename used across all related files
gameId	string	Internal UUID
matchId	number	Official AoE2 match ID
isRanked	bool	Whether the match was ranked
gameMode	number	Game mode ID
mapName	string	Resolved map name
durationMs	number	Match duration in milliseconds
startTime	number	Match start time as a Unix timestamp
startDate	string	Match start time as ISO 8601
split	string	Dataset split: train, validation, or test
players	array	Per-player metadata (see below)
paths	object	Relative paths to all associated files (see below)

Splits: Games are assigned to train (80%), validation (10%), and test (10%) splits via a deterministic hash of the game name. The same game always receives the same split regardless of when it was added to the dataset. The split is provided for reproducibility and convenience, if your use case does not require a held-out set, treat the full index.json as a single corpus. The companion files index_train.json, index_validation.json, and index_test.json each follow the same structure as index.json and contain only games for that split.

Player fields

Field	Type	Description
playerId	number	In-game player slot (matches id in players.arrow)
name	string	Player name
profileId	number | null	Relic profile ID, may be null if not found in the API
civId	number	Civilisation ID
civName	string	Civilisation name
elo	number	ELO at time of collection
won	bool	Whether this player won
gameStatus	number	Final game status code (2 = winner)

paths

Relative paths from the dataset root to each associated file for this game.

Field	Description
caderec	Path to the .caderec file
aoe2rec	Path to the .aoe2record file
export.<binWidth>.arrow	Path to the Arrow zip for the given window width
export.<binWidth>.parquet	Path to the Parquet zip for the given window width

This document was manually written then formatted & cleaned using LLMs, feel free to correct any errors or ask for clarification.