Reference

Events

Content type: events
Files: data/events.json, data/events/calendar/
Shape: A list of records, each with its own id
Patch target: event:<id>, for example event:core.event.asia-tour-event-10
In the base game: 2407 records
Guide: Scenes: a country's own darts, Tours and the Tour Card, Calendar and entry rules

Fields#

Indented fields belong to the field above them. [] marks the items of a list. A field that is not required may be left out; the default is used.

Field	Type	Required	Default	Notes
`id`	id	Yes		Namespaced id, e.g. "core.player.rory-calder"
`tourId`	id	Yes		Namespaced id, e.g. "core.player.rory-calder" Names a tour record.
`name`	text	Yes
`shortName`	text, up to 20 characters
`logo`	file path			A file in your pack: see Images, sound and models.
`board`	one of the options			steel or soft (soft-tip boards), over the tour's board; steel when neither says. The match itself plays as before for now. Options: `steel`, `soft`.
`stage`	text, up to 40 characters
`trophy`	text, up to 60 characters
`broadcast`	id			Namespaced id, e.g. "core.player.rory-calder"
`organisation`	id			The organisation (by id) that runs this event, when it is not its tour's.
`venueId`	id	Yes		Namespaced id, e.g. "core.player.rory-calder" Names a venue record.
`month`	whole number, 1 to 12	Yes
`week`	whole number, 1 to 5	Yes		Week of the month the event starts (the n-th such weekday; 5 may roll into next month)
`days`	whole number, 1 to 28		`1`
`schedule`	object
`schedule.roundDays`	list, 1 to 16 items
`schedule.restDays`	list, up to 31 items
`fieldSize`	whole number, 2 to 256	Yes
`entry`	one of the options	Yes		Options: `open`, `tourCard`, `invitation`, `ranking`.
`seeds`	whole number, at least 0		`0`	For 'ranking' entry: how many from the Order of Merit get in.
`rounds`	list	Yes		Round formats, first round → final. Length must be log2(field after groups).
`rounds[]`	one of several shapes	Yes
Shape 1 (with `bestOfLegs`)
`rounds[].bestOfLegs`	whole number, 1 to 41	Yes
`rounds[].tieBreak`	object
`rounds[].tieBreak.winBy`	whole number, 2 to 3	Yes
`rounds[].tieBreak.suddenDeathAt`	whole number, 1 to 30
Shape 2 (with `bestOfSets`)
`rounds[].bestOfSets`	whole number, 1 to 13	Yes
`rounds[].legsPerSet`	whole number, 3 to 9		`5`
`rounds[].decidingSet`	object
`rounds[].decidingSet.winBy`	whole number, 2 to 3	Yes
`rounds[].decidingSet.suddenDeathAt`	whole number, 1 to 30
`groups`	object
`groups.count`	whole number, at least 1	Yes
`groups.size`	whole number, 3 to 8	Yes
`groups.advance`	whole number, 1 to 4	Yes
`groups.format`	one of several shapes	Yes
Shape 1 (with `bestOfLegs`)
`groups.format.bestOfLegs`	whole number, 1 to 41	Yes
`groups.format.tieBreak`	object
`groups.format.tieBreak.winBy`	whole number, 2 to 3	Yes
`groups.format.tieBreak.suddenDeathAt`	whole number, 1 to 30
Shape 2 (with `bestOfSets`)
`groups.format.bestOfSets`	whole number, 1 to 13	Yes
`groups.format.legsPerSet`	whole number, 3 to 9		`5`
`groups.format.decidingSet`	object
`groups.format.decidingSet.winBy`	whole number, 2 to 3	Yes
`groups.format.decidingSet.suddenDeathAt`	whole number, 1 to 30
`groups.byes`	whole number, 0 to 32			The top `byes` seeds skip the group stage and go straight into the knockout (field = count × size + byes; knockout = count × advance + byes).
`groups.table`	one of the options			Options: `combined`.
`cascade`	object
`cascade.format`	one of several shapes	Yes
Shape 1 (with `bestOfLegs`)
`cascade.format.bestOfLegs`	whole number, 1 to 41	Yes
`cascade.format.tieBreak`	object
`cascade.format.tieBreak.winBy`	whole number, 2 to 3	Yes
`cascade.format.tieBreak.suddenDeathAt`	whole number, 1 to 30
Shape 2 (with `bestOfSets`)
`cascade.format.bestOfSets`	whole number, 1 to 13	Yes
`cascade.format.legsPerSet`	whole number, 3 to 9		`5`
`cascade.format.decidingSet`	object
`cascade.format.decidingSet.winBy`	whole number, 2 to 3	Yes
`cascade.format.decidingSet.suddenDeathAt`	whole number, 1 to 30
`cascade.order`	one of the options		`"field"`	Options: `field`, `seriesAverage`.
`cascade.stages`	list, at least 1 item	Yes
`cascade.stages[].id`	text	Yes
`cascade.stages[].groups`	whole number, 1 to 8		`1`
`cascade.stages[].size`	whole number, 2 to 8	Yes
`cascade.stages[].advance`	whole number, 1 to 4
`cascade.stages[].new`	whole number, 0 to 64
`cascade.stages[].from`	list
`cascade.stages[].from[].stage`	text	Yes
`cascade.stages[].from[].places`	list, at least 1 item	Yes
`cascade.stages[].name`	text
`cascade.stages[].dayFrom`	whole number, 1 to 7
`cascade.stages[].dayTo`	whole number, 1 to 7
`cascade.stages[].meetings`	whole number, 1 to 4		`1`
`cascade.knockoutDays`	list, at least 1 item
`startScore`	whole number		`501`
`doubleIn`	true or false		`false`
`finish`	one of the options		`"double"`	Options: `double`, `single`.
`formatBands`	list, at least 1 item
`formatBands[].maxLevel`	whole number, 0 to 100	Yes
`formatBands[].startScore`	whole number	Yes
`formatBands[].finish`	one of the options		`"double"`	Options: `double`, `single`.
`prizes`	list, at least 1 item	Yes		Prize money by finishing position: [winner, runner-up, semi-finalist, quarter-finalist, …].
`entryFee`	whole number, at least 0		`0`
`ranked`	true or false		`true`	Counts towards the Order of Merit.
`tv`	true or false		`false`
`major`	true or false		`false`
`crowd`	number, 0 to 1		`0.3`	0..1 crowd size/energy for presentation and pressure.
`tags`	list		`[]`	Special meanings for the career engine: "qschool", "worldChampionship", "playersFinals", "youth" (under-25s only), "county", "leagueNight" (a night of a league: winning it is not a title).
`online`	true or false
`teams`	object			Team event: the field is `fieldSize` teams. "nations" = each nation's top `size` players on the Order of Merit, playing pairs matches.
`teams.kind`	one of the options	Yes		Options: `nations`, `squads`, `pairs`.
`teams.size`	whole number, 2 to 4	Yes
`teams.squads`	list, 2 to 64 items
`teams.ranking`	text			The ranking that picks each nation's players and orders the nations. Default "oom". Pattern: `^(oom\|tour:.+\|season:.+\|last:.+\|phase:.+\|stage:.+\|average:.+\|rolling:.+)$`
`teams.nationRankings`	list, 1 to 16 items			Nations events only: for the nations listed, pick players from another ranking first (an affiliate tour's list). Each nation listed takes its players in the top `keepTop` of the event's ranking first, then its best on this ranking, then its best as any other nation. The nations are still ordered and seeded on the event's own ranking.
`teams.nationRankings[].ranking`	text	Yes		A ranking a route can read: "oom" (the two-year Order of Merit), "tour:<tourId>" (that tour's own table: two years when its rules say rolling2y, else this season) or "season:<tourId>" (this season's money on that tour). Pattern: `^(oom\|tour:.+\|season:.+\|last:.+\|phase:.+\|stage:.+\|average:.+\|rolling:.+)$`
`teams.nationRankings[].nations`	list, 1 to 64 items	Yes
`teams.nationRankings[].keepTop`	whole number, 1 to 1000			How far down the event's own ranking a listed nation's players are still picked first. Omitted: none are.
`teams.pick`	one of the options			Options: `best`, `turns`.
`teams.turnsFromAge`	whole number, 1 to 99
`teams.sides`	whole number, 2 to 8
`teams.regions`	map (key: value)
`teams.homes`	map (key: value)
`teams.areas`	map (key: value)
`teams.county`	true or false
`teams.minPlayers`	whole number, 1 to 4			Fewest players a nation needs to enter (default `size`). Below `size` the team is short-handed and `missingPartner` decides how it plays.
`teams.minAge`	whole number, 1 to 99			Nations events only: the youngest age, on the event's first day, a player must be to play for a nation. A nation with too few players old enough plays short-handed, down to `minPlayers`, or sits out.
`teams.missingPartner`	one of the options			A short-handed team in a pairs match: "solo" = its player throws every visit (start score + `soloHandicap` each leg); "bye" = it concedes the pairs match (a walkover). Singles against a missing player are always walkovers. Default "solo". Options: `solo`, `bye`.
`teams.soloHandicap`	whole number, 0 to 200			Points added to a lone player's start score in each pairs leg (0 = none).
`teams.host`	one of several shapes			Host nation: always in the field (a nation code, or "venue" = the venue's country).
Shape 1: nation code
Shape 2: exactly "venue"
`teams.prizeSplit`	one of the options			Prize money: "each" = every player gets the listed prize (default); "share" = it's per team, split between the players. Options: `each`, `share`.
`teams.ties`	list			Knockout rounds played as team ties (singles and pairs rubbers). Others: one pairs match.
`teams.ties[].from`	whole number, at least 1	Yes
`teams.ties[].to`	whole number, at least 1
`teams.ties[].rubbers`	list, 1 to 9 items	Yes
`teams.ties[].rubbers[]`	one of several shapes	Yes		One rubber of a team tie: a singles match between the teams' `a`-th and `b`-th players (1 = each team's best ranked), or a pairs match.
When `kind` is `"singles"`
`teams.ties[].rubbers[].kind`	exactly `"singles"`	Yes
`teams.ties[].rubbers[].a`	whole number, 1 to 4	Yes
`teams.ties[].rubbers[].b`	whole number, 1 to 4	Yes
When `kind` is `"pairs"`
`teams.ties[].rubbers[].kind`	exactly `"pairs"`	Yes
`teams.ties[].toWin`	whole number, 1 to 5	Yes
`teams.table`	object
`teams.table.series`	text, up to 80 characters	Yes
`teams.table.win`	whole number, 0 to 10	Yes
`teams.table.loss`	whole number, 0 to 10
`teams.table.order`	list, 1 to 5 items	Yes
`teams.table.tiers`	list, 1 to 8 items
`teams.table.tiers[]`	list, 2 to 32 items	Yes
`teams.table.move`	whole number, 0 to 8
`teams.table.from`	whole number, 1 to 12
`teams.tier`	whole number, 1 to 8
`teams.fixtures`	object
`teams.fixtures.round`	whole number, 1 to 62	Yes
`league`	one of several shapes			League series (e.g. a weekly TV league). A night: every line-up player plays one fixture (`fieldSize` = `players`, one entry in `rounds`). The play-off night: a knockout of the table's top `top` (`fieldSize` = `top`).
Shape 1 (with `series`, `night`, `nights`)
`league.series`	text	Yes
`league.night`	whole number, at least 1	Yes
`league.nights`	whole number, at least 1	Yes
`league.players`	whole number, 3 to 32	Yes
`league.format`	one of the options			'fixtures' (default): each player plays one round-robin fixture. 'knockout': the line-up plays a knockout (`rounds` = its rounds) and earns `points[position]` (0 = winner, 1 = runner-up, 2 = semi-finalist…). Options: `fixtures`, `knockout`.
`league.points`	list, at least 1 item
Shape 2 (with `series`, `playoffs`, `top`)
`league.series`	text	Yes
`league.playoffs`	exactly `true`	Yes
`league.top`	whole number, 2 to 16	Yes
`weekday`	whole number, 0 to 6			Day of the week the event starts (0 = Sunday … 4 = Thursday … 6 = Saturday). Omitted = Saturday. The start is that weekday in `week` of `month`.
`wholeWeek`	true or false			true: the event keeps to the real week (Monday to Sunday) of the month's `week`-th Saturday, even when that week begins in the month before, so a Monday-to-Saturday series has a week of its own for every `week`. Never before 1 January: there week 1 moves a week later and shares its days with week 2. Omitted: a weekday event of a week whose Monday falls in the month before moves a week later.
`endsInNewYear`	object			For an event that ends its season across New Year, such as a world championship: its final is on `day` January of the next year (with `weekday`, the first such weekday on or after that day), and the season ends after it. `month` and `week` then only set its place in the season's order.
`endsInNewYear.day`	whole number, 1 to 31	Yes		The day in January of the event's last day.
`endsInNewYear.weekday`	whole number, 0 to 6			Optional: 0 = Sunday to 6 = Saturday. The last day is the first such weekday on or after `day`.
`opensSeason`	true or false			The event starts the day its season opens: the day after the last season's final across New Year, or 1 January without one. With `weekday`, the first such weekday on or after that day (Trial Week: the first Monday on or after 4 January). `month` and `week` only set its order.
`series`	text
`entryRoutes`	list, at least 1 item			How the field is filled, route by route (see EntryRoute). Omitted = the tour tier's built-in selection. With routes the tier's Tour Card rules don't apply; `restrict` still does. The human gets in through ranking, winners, qualifier and players routes (never a simulated pool).
`entryRoutes[]`	one of several shapes	Yes		One way into an event's field. Routes run in order; each skips players who are already in, and none goes past the field size. See Calendar and entry rules.
When `kind` is `"ranking"`
`entryRoutes[].kind`	exactly `"ranking"`	Yes
`entryRoutes[].ranking`	text	Yes		A ranking a route can read: "oom" (the two-year Order of Merit), "tour:<tourId>" (that tour's own table: two years when its rules say rolling2y, else this season) or "season:<tourId>" (this season's money on that tour). Pattern: `^(oom\|tour:.+\|season:.+\|last:.+\|phase:.+\|stage:.+\|average:.+\|rolling:.+)$`
`entryRoutes[].top`	whole number, 1 to 256	Yes		How many players this route adds (the best N not already in).
`entryRoutes[].from`	whole number, at least 1			Start at this rank (1 = top).
`entryRoutes[].within`	true or false			Only look at ranks from..from+top-1 (players already in use up their place).
`entryRoutes[].cardHolders`	true or false			Only Tour Card holders count (and are counted).
`entryRoutes[].maxAge`	whole number, 1 to 99
`entryRoutes[].nations`	list, at least 1 item			Only players of these nationalities.
`entryRoutes[].seed`	true or false
`entryRoutes[].label`	text
When `kind` is `"winners"`
`entryRoutes[].kind`	exactly `"winners"`	Yes
`entryRoutes[].events`	list, at least 1 item	Yes		Event template ids whose winners get in.
`entryRoutes[].within`	one of the options			'season' = won this season (default); '12months' = in the 12 months before the event. Options: `season`, `12months`.
`entryRoutes[].top`	whole number, at least 1			At most this many (most recent wins first).
`entryRoutes[].finalists`	true or false
`entryRoutes[].seed`	true or false
`entryRoutes[].label`	text
When `kind` is `"qualifier"`
`entryRoutes[].kind`	exactly `"qualifier"`	Yes
`entryRoutes[].event`	id	Yes		A template with `qualifies` pointing at this event. Names a event record.
`entryRoutes[].seed`	true or false
`entryRoutes[].label`	text
When `kind` is `"pool"`
`entryRoutes[].kind`	exactly `"pool"`	Yes
`entryRoutes[].pool`	one of the options	Yes		Who a simulated route picks from. Options: `cardHolders`, `nonCardHolders`, `women`, `youth`, `any`.
`entryRoutes[].nations`	list, at least 1 item			Only players of these nationalities.
`entryRoutes[].count`	whole number, 1 to 256	Yes
`entryRoutes[].pick`	one of the options	Yes		How a simulated route picks players: best ranked, best level, or random weighted by level. Options: `ranking`, `level`, `weighted`.
`entryRoutes[].seed`	true or false
`entryRoutes[].label`	text
When `kind` is `"players"`
`entryRoutes[].kind`	exactly `"players"`	Yes
`entryRoutes[].ids`	list, at least 1 item	Yes
`entryRoutes[].seed`	true or false
`entryRoutes[].label`	text
When `kind` is `"fill"`
`entryRoutes[].kind`	exactly `"fill"`	Yes
`entryRoutes[].pool`	one of the options	Yes		Who a simulated route picks from. Options: `cardHolders`, `nonCardHolders`, `women`, `youth`, `any`.
`entryRoutes[].nations`	list, at least 1 item			Only players of these nationalities.
`entryRoutes[].pick`	one of the options	Yes		How a simulated route picks players: best ranked, best level, or random weighted by level. Options: `ranking`, `level`, `weighted`.
`entryRoutes[].scenePlayers`	true or false			Also take players a scene created for its own residents' events, where the event's own rules allow them: a youth championship drawn from every player of its ages in the world, not only those on the travelling circuit.
`entryRoutes[].seed`	true or false
`entryRoutes[].label`	text
When `kind` is `"form"`
`entryRoutes[].kind`	exactly `"form"`	Yes
`entryRoutes[].ranking`	text	Yes		A ranking a route can read: "oom" (the two-year Order of Merit), "tour:<tourId>" (that tour's own table: two years when its rules say rolling2y, else this season) or "season:<tourId>" (this season's money on that tour). Pattern: `^(oom\|tour:.+\|season:.+\|last:.+\|phase:.+\|stage:.+\|average:.+\|rolling:.+)$`
`entryRoutes[].pool`	whole number, 1 to 1024	Yes
`entryRoutes[].top`	whole number, 1 to 256	Yes		How many players this route adds (the best N not already in).
`entryRoutes[].seed`	true or false
`entryRoutes[].label`	text
`qualifies`	object			This event is a qualifier: play stops when `count` players remain, and they are in the `event` template's field this season (via its `{ kind: 'qualifier' }` route). The draw is `count` sections of 2^rounds slots, each section's winner qualifying, so `rounds` = ceil(log2(fieldSize / count)): e.g. 128 for 32 → 2 rounds, 128 for 24 → 3.
`qualifies.event`	id			Namespaced id, e.g. "core.player.rory-calder" Names a event record.
`qualifies.events`	list, 1 to 16 items
`qualifies.count`	whole number, 1 to 128	Yes
`qualifies.earlyRounds`	true or false			Marks a staged event: these are the early rounds, and the event named in `event` is its final. The final's winner takes the title; the early rounds give none. An edition played in a season with no final counts as the whole event.
`entryStages`	list, at least 1 item			Staggered entry: the best `top` of the field (seeds first, then Order of Merit) start in round `round` (1 = first round), the next stage's players in its round, and so on; everyone else starts in round 1.
`entryStages[].top`	whole number, at least 1	Yes
`entryStages[].round`	whole number, at least 2	Yes
`restrict`	object			Who may play. Replaces the tour tier's entry rules (Tour Card / Challenge status) with these checks; omitted fields don't restrict.
`restrict.gender`	one of the options			Options: `m`, `f`.
`restrict.maxAge`	whole number, 10 to 99			Oldest age allowed on the start date (23 = under-24s).
`restrict.minAge`	whole number, 10 to 99
`restrict.pathwayAge`	whole number, 10 to 99
`restrict.maxPerYear`	whole number, 1 to 99
`restrict.maxPerSeries`	whole number, 1 to 99
`restrict.nations`	list, at least 1 item
`restrict.tourCard`	true or false			true = Tour Card holders only, false = non-holders only.
`restrict.cardHolderOnce`	text
`restrict.minLevel`	whole number, 0 to 100
`restrict.maxLevel`	whole number, 0 to 100
`restrict.band`	whole number, 1 to 50
`restrict.residents`	true or false
`restrict.unsigned`	true or false
`restrict.retired`	true or false
`restrict.exclude`	list, 1 to 4 items
`restrict.exclude[].ranking`	text	Yes		A ranking a route can read: "oom" (the two-year Order of Merit), "tour:<tourId>" (that tour's own table: two years when its rules say rolling2y, else this season) or "season:<tourId>" (this season's money on that tour). Pattern: `^(oom\|tour:.+\|season:.+\|last:.+\|phase:.+\|stage:.+\|average:.+\|rolling:.+)$`
`restrict.exclude[].top`	whole number, 1 to 256	Yes
`whenBackground`	one of the options			Options: `played`, `quick`.
`discontinued`	true or false
`resolve`	one of the options			Options: `quick`.
`drawShow`	true or false			The draw is made on television: a story in the news when it is made, with a Watch the draw button that plays it as a 3D cut scene. Omitted = majors only.
`follows`	id			Another event's id: this one starts `followsDays` days after that event's start, at the same venue, whatever its own `month` and `week` say. A qualifier that follows its event moves with it every year. In a season without that event, this one falls back to its own date.
`followsDays`	whole number, 0 to 28			How many days after the followed event's start this one starts: 0 (the same day) to 28. On the same day the two do not clash.
`within`	id			Another event's id: this one is played on one of that event's own days, at its hall (a youth final on the Circuit Finals' Sunday). A player in both plays both; the host's matches come first.
`draw`	one of the options			Options: `eachRound`, `rumble`.
`redrawFrom`	whole number, at least 2
`prizeDeal`	object
`prizeDeal.category`	text	Yes
`prizeDeal.seasons`	whole number, 1 to 5	Yes
`minAge`	whole number, 0 to 99			The youngest age on the start date. Replaces the tour's own minimum age; 0 = no limit whatever the tour says. Unlike `restrict` it leaves the tier's Tour Card rules in place.

Example#

A record from the base game’s data/events/calendar/asia-pro.json, shortened.

{
  "id": "core.event.asia-tour-event-10",
  "tourId": "core.tour.asia-pro",
  "name": "Jade Tour: Event 10",
  "venueId": "core.venue.victoriaharbour-harbour-hall",
  "month": 5,
  "week": 1,
  "follows": "core.event.asia-tour-event-09",
  "followsDays": 0,
  "days": 1,
  "fieldSize": 64,
  "entry": "open",
  "rounds": [
    {
      "bestOfLegs": 7
    },
    {
      "bestOfLegs": 7
    },
    {
      "bestOfLegs": 7
    },
    /* … 3 more */
  ],
  "prizes": [
    2500,
    1250,
    750,
    /* … 4 more */
  ],
  "ranked": false,
  "tv": false,
  "major": false,
  "crowd": 0.3,
  "tags": [],
  "entryFee": 30,
  "shortName": "Jade Tour 10",
  "stage": "hall",
  "minAge": 16,
  "logo": "assets/orgs/core.org.dso-asia.webp"
}

In your pack the record’s id starts with your pack’s id instead of core, unless you mean to replace this one.

Written for Darts Player Simulator 0.50.32. Built from the game's own schemas and its base pack.