Map list generator · Modules

1 module · 3 exports · 0 repositories · 5 e2e tests · 1 route

OverviewModulesSearch params & storageE2E tests

Who imports who · hover a node

MapList

app/features/map-list-generator/core/MapList.ts

No overview comment at the top of the file.

Imports

no other modules

Used by

1 route1 module3 other

Functions & values

function

modeStageKey

:29

Unique key of a mode-stage combination, e.g. modeStageKey("SZ", 1) gives "SZ-1".

export function modeStageKey(mode: ModeShort, stageId: StageId): string

Othersendouq/default-maps.server.tssendouq-match/match.server.ts

function

generate

:42

Generates map lists avoiding stage repeats, optionally following a mode pattern.

• @example

  const generator = generate({ mapPool: new MapPool(pool) }); generator.next(); const firstSet = generator.next({ amount: 5 }).value; const secondSet = generator.next({ amount: 3, pattern: "SZ*TC" }).value; // remembers stages used in firstSet

export function* generate(args: {
	mapPool: MapPool;
	/** Bias towards maps not guaranteed to be played (e.g. maps 4 & 5 of a Bo5). True for best of formats. */
	considerGuaranteed?: boolean;
	/** Initial weights keyed by `modeStageKey`. Negative weights deprioritize maps. */
	initialWeights?: Map<string, number>;
	/** Skip inflating weights so half the pool is available, e.g. when initial weights already define the selection. */
	skipEnsureMinimumCandidates?: boolean;
	/** Fixed mode order instead of a random shuffle. Intended for `resume`. */
	modeOrder?: ModeShort[];
	/** Mode-agnostic initial stage weights, how `resume` carries over stage-level penalties from history. */
	initialStageWeights?: Map<StageId, number>;
	/** Filters per map index of a set, tried in order. The first one leaving any candidate narrows the draw. */
	candidateFilters?: (index: number) => Array<(map: ModeWithStage) => boolean>;
}): Generator<Array<ModeWithStage>, Array<ModeWithStage>, GenerateNext>

Unit tests (35)

• singular map list › returns an array of %d items× 3
• singular map list › includes
  • only maps from the given map pool
  • a mustInclude mode
  • a mustInclude mode (guaranteed)
  • a mustInclude mode with pattern
• singular map list › contains
  • only unique maps, when possible
  • every mode once before repeating
• singular map list › repeats
  • maps when amount is larger than pool size
  • a mode following the pattern when amount bigger than mode count
• singular map list › does not repeat the stage order when the list goes through every stage twice
• singular map list › handles
  • empty map pool
  • a conflict between pattern and must include
  • more must include modes than amount
• singular map list › follows
  • a pattern
  • and repeats a pattern
  • a one mode only pattern
  • a pattern where starting and ending mode is the same
  • a one mode only pattern (Bo9)
  • a pattern with multiple specific modes
• singular map list › guarantees a must-include even when the pattern's only ANY slot is in the back half
• singular map list › places a non-guaranteed must-include when the pattern has no flexible slots but more maps than pattern parts
• singular map list › ignores
  • a mode in the pattern not in the map pool
  • a must include mode not in the map pool
• many map lists › generates many map lists
• many map lists › has different maps in each list
• many map lists › randomizes the stage order
• many map lists › cycles a single mode order continuously across sets
• many map lists › uses the same mode order when a set spans the whole rotation
• many map lists › keeps
  • cycling other modes across sets when a must-include pattern is set
  • cycling other modes across sets when a positional pattern is set
• many map lists › advances the cycle by the ANY slots consumed when a positional pattern is set
• many map lists › replenishes the stage id pool with different order
• many map lists › finds
  • unique maps when possible (All 4 One #50 bug)
  • unique maps when possible (All 4 One #51 bug)
• many map lists › applies different weight penalties based on guaranteed positions when considerGuaranteed is true

Routes/maps

Othersendouq-match/match.server.tstournament-bracket/toMapList.ts

function

resume

:152

Generator primed to continue after history: mode order kept stable (rotated so the next mode is first) and played (mode, stage) pairs avoided unless every option in that mode was played.

• @example

  const generator = resume({ mapPool, history }); generator.next(); const { mode, stageId } = generator.next({ amount: 1 }).value![0];

export function resume(args: {
	mapPool: MapPool;
	history: Array<{ mode: ModeShort; stageId: StageId }>;
})

Unit tests (6)

• starts with the pool's first mode when history is empty
• rotates
  • through modes in pool order across history length
  • only through modes present in the pool
• wraps the mode order back to the start after a full rotation
• avoids
  • already-played (mode, stage) pairs
  • the just-played stage when alternatives exist, even across modes

Modulesscrims/ScrimMapByMap.ts

Unit tests not about one export (19)

• MapList.generate() with initialWeights › accepts initialWeights parameter without errors
• MapList.generate() with initialWeights › handles
  • empty initialWeights
  • undefined initialWeights
• MapList.generate() with initialWeights › initialWeights affect stage selection
• MapList.generate() with candidateFilters › draws
  • from the first filter that leaves any candidate
  • from every candidate when no filter leaves any
• MapList.generate() with candidateFilters › passes the map's index in the set to the filters
• parses
  • a simple pattern
  • a mustInclude mode
  • a guaranteed mustInclude mode
  • a complex pattern
  • an empty pattern
• handles
  • extra spaces
  • the same mode twice in pattern
• returns
  • error on invalid mode
  • error when pattern is too long
• if starts and ends with ANY, the ending ANY is dropped
• ignores repeated must include mode
• return error on lorem ipsum

Not shown, only used by tests: parsePattern