Custom Data Packs

A Data Pack is a single JSON file that replaces the game's default fictional league with your own conferences, teams, and players. Import one from a local file or a hosted URL on the Data Packs screen in the main menu — importing a custom pack is a one-time Premium unlock. This page documents every field the app reads and the validation rules enforced on import — the exact schema, straight from the app's own code.

1. Quick Start

The smallest valid pack is a JSON object with pack_name, version, conferences, teams, and players that satisfies these minimums:

• at least 1 conference
• at least 4 teams
• at least 1 player
• every team has at least 12 skaters and 2 goalies

JSON keys are snake_case. All IDs are UUID strings (standard 8-4-4-4-12 hex format). They just need to be unique within the pack and used consistently to link records together — a team's conference_id points at a conference's id, and a player's team_id points at a team's id.

2. Top-Level Structure

3. Conferences

4. Teams

5. Players

6. The stats object — one prior season only

A pack can only carry a single prior-season stat line per player, and it's optional. When present, it's surfaced on the player's profile as their one season of pre-import history and seeds their career totals — it does not create multiple season rows.

Every field defaults to 0 and every field is present on every player's stat object regardless of position. The season label shown on the profile is derived from the pack's start_year: with "start_year": 2025, a player's stats line is dated the 2024-25 season.

7. Independent Conferences

An independent grouping (teams that don't belong to any conference) schedules games and is ranked in the national index like any other conference, and crowns its own postseason champion, but grants no automatic National Tournament bid — its teams can only reach the tournament via an at-large bid.

Mark a conference as independent with "is_independent": true. If omitted, the app still infers independence when the conference's name contains "independent" (any case) or its resolved abbreviation is exactly "IND" — a custom-named independent grouping should set the flag explicitly to avoid surprises. Regardless of tournament shape, an independent conference can never grant an automatic bid — is_independent always wins over any grants_auto_bid you set.

Independent conferences default to a 5-team, top-3-bye, neutral-site single-elimination bracket with a consolation round unless overridden. The engine currently schedules an independent grouping the same way it schedules a real conference (games are drawn from within the group) — expect intra-group scheduling rather than bespoke non-conference scheduling.

8. Team Composition & Roster Rules

In short: the validator only guarantees a team is viable to field a lineup (12 skaters + 2 goalies). Hitting the positional minimums exactly and aiming for a realistic ~34-man roster is a quality bar for your pack, not something the importer blocks on.

9. Abbreviation Derivation

If a team or conference omits abbreviation, the app derives one from name:

• Single-word names take their first three letters, uppercased: "Ridgeview" → RID.
• Multi-word names (splitting on spaces and hyphens) take the leading initial of each word (up to 4 words), uppercased: "North Shore" → NS, "St. Croix State" → SCS, "Lake-Superior" → LS.

Supply an explicit abbreviation any time the derived one would be ambiguous (two teams deriving to the same code) or just isn't the code you want.

10. Conference Tournament Format

By default, a conference's postseason format falls back to a generic bracket sized to its team count. To model a real conference's actual format, author it one of two ways — inline wins over a named preset; either wins over the default.

Valid preset keys: big_ten, ccha, nchc, ecac, hockey_east, atlantic_hockey, uchc.

An inline spec looks like:

"tournament": {
  "field_size": 8,
  "bye_count": 0,
  "grants_auto_bid": true,
  "rounds": [
    { "label": "Quarterfinals", "wins_required": 2, "venue": "higher_seed_hosts", "seeding": "bracket_advance" },
    { "label": "Semifinals",    "wins_required": 1, "venue": "neutral_site",       "seeding": "reseed_by_standing" },
    { "label": "Championship",  "wins_required": 1, "venue": "neutral_site",       "seeding": "reseed_by_standing" }
  ]
}

Whatever shape you author is validated against the conference's actual team count on import: if it doesn't cleanly fit, the round count is regenerated for the real field while preserving each round's authored flavor as closely as possible. A pack can never produce a broken bracket, even with a wrong team count.

11. Referential Integrity & Uniqueness

The importer runs these checks, in order, and reports every failure at once so you can fix a pack top-to-bottom in one pass:

• Non-empty. pack_name and version non-blank; ≥ 1 conference, ≥ 4 teams total, ≥ 1 player.
• Referential integrity. Every team's conference_id matches a conference id; every player's team_id matches a team id.
• Value ranges — see the tables above for each field.
• Enum membership. position, archetype, and year must each match an exact listed value.
• Roster minimums. Every team needs ≥ 1 player, ≥ 12 skaters, ≥ 2 goalies.
• UUID uniqueness. No id may repeat across the combined pool of conferences, teams, and players.

A pack that fails validation is never partially imported — it's all-or-nothing. Malformed JSON that doesn't even reach the validator (a missing key, wrong type, corrupted syntax) is reported separately, naming the specific key/path Swift's decoder choked on.

On-disk storage is keyed by the pack's stable ID (derived from pack_name), not by a hand-slugged filename — two differently-named packs can never collide, and re-importing a pack with the same name always updates the same file rather than creating a duplicate.

12. Importing a Pack

From the Data Packs screen (main menu → Data Packs):

• Import from file — pick any .json file via the system file picker.
• Import from URL — paste an http:// or https:// link to a hosted JSON file.

Either path decodes the JSON, runs the full validation pass above, and — only if it passes — saves a local copy and adds it to your pack list. You can then mark any imported pack as the default, which pre-selects it the next time you start a new game.

13. Pro Teams (Draft Destinations)

Every dynasty runs a fictionalized Pro Draft (see Pro Draft & Turning Pro) where your best college players get selected by one of 32 fictional pro teams. By default those 32 names come from the game's own built-in list (real city names, invented team names — no real league's trademark). A pack can supply pro_teams instead, so players drafted out of your custom league land on team names that fit your world:

"pro_teams": [
  "Boston Schooners", "Toronto Skyliners", "New York Statesmen", "..."
]

• Supply at least 32 unique, non-blank names — the draft board always fills all 32 slots for a given dynasty, drawing them at random from whatever list you provide. Give more than 32 and each new dynasty (and the in-season mock draft board) gets a different random 32-team subset instead of the identical 32 every time.
• Omit the field entirely to use the built-in list — there's no way to override part of it while keeping the rest.
• This only names where a prospect gets drafted to — it has no effect on your college conferences, teams, or player attributes.

See Also

• Data Pack Builder — build a pack in your browser
• Program Prestige & Job Security
• Recruiting
• Attributes, Archetypes & Ratings
• Glossary