@opndev/tennis-match-center 0.0.2 → 0.0.4

package/lib/run-queue-planner.mjs

@@ -6,12 +6,20 @@ import { bandDistance, computeSectionBands, sectionsFor } from './court-bands.mj
 import { groupRuns } from './group-schedule.mjs'
 
 /**
- * Where a group should land the day after playing a given section:
- * S1 to S3, S2 to S4, S3 to S1, S4 to S2 - prio.pl's rotation. A
- * group that played late one day plays early the next and the other
- * way round, so nobody gets two late finishes or two early starts.
+ * Where a group should land the day after playing a given section: two
+ * sections on, wrapping round. With four that is S1 to S3, S2 to S4, S3
+ * to S1 and S4 to S2 - prio.pl's rotation, where a group that played
+ * late one day plays early the next. With three it is S1 to S3, S2 to
+ * S1 and S3 to S2, so nobody plays the same block twice running and
+ * nobody who finished late starts early.
+ *
+ * @param {number} previous The section it played last.
+ * @param {number} sectionCount
+ * @returns {?number} null where there are too few sections to rotate.
  */
-const SECTION_OFFSET = { 0: 2, 1: 3, 2: 0, 3: 1 }
+function rotationTarget(previous, sectionCount) {
+  return sectionCount >= 3 ? (previous + 2) % sectionCount : null
+}
 
 // Mirrors GameCounter::GAMES_PER_GROUP server-side: how many matches a
 // full group of this size plays. Used only to report a group with no
@@ -21,6 +29,102 @@ const GAMES_PER_POOL_SIZE = { 3: 3, 4: 6, 5: 10 }
 
 const queueKey = (competitionId, date) => `${competitionId}:${date}`
 
+/**
+ * What is left of a run once the fixtures already in the plan are
+ * taken out.
+ *
+ * @param {{positions: Array<?number>, indices: number[]}} run
+ * @param {number} groupId
+ * @param {?Function} done (groupId, index) => whether it is in the plan
+ * @returns {?Object} the run, shortened, or null when nothing is left
+ */
+export function remainderOf(run, groupId, done) {
+  if (done === null) {
+    return run
+  }
+
+  const owed = run.positions.filter(
+    position => position !== null && !done(groupId, position)
+  )
+
+  if (owed.length === 0) {
+    return null
+  }
+
+  if (owed.length === run.positions.filter(position => position !== null).length) {
+    return run
+  }
+
+  return { ...run, positions: owed, indices: owed }
+}
+
+/**
+ * How a section can be shared when courts are scarce.
+ *
+ * A run is one group on one court for its whole stretch. When courts
+ * drop out part way through a section, only the courts that last it
+ * can host a run, and the rest of the room goes spare - the front of
+ * the section has every court, the back only some. Whatever the reason
+ * a court drops out, the answer is the same: a group plays the front of
+ * its run on a court of its own while that court exists, and the back
+ * of it on one of the courts that remain, which two groups share by
+ * taking turns. Nobody waits longer than a match for their next.
+ *
+ * The section is then as long as the front plus two backs.
+ *
+ * Only the last section that loses courts is shared, and only when
+ * sharing holds more groups than whole runs do.
+ *
+ * @param {Object} params
+ * @param {Array} params.own The competition's slots that day.
+ * @param {Array} params.sections see sectionsFor
+ * @param {number} params.runLength
+ * @param {Array} params.courts
+ * @param {Function} params.usable (court, slot) => boolean
+ * @returns {?{index: number, first: number, front: number, back: number,
+ *   length: number, capacity: number}}
+ */
+export function sharedSectionFor({ own, sections, runLength, courts, usable }) {
+  for (let index = sections.length - 1; index >= 0; index--) {
+    const first = index * runLength
+    const open = courts.filter(court => usable(court, own[first]))
+
+    let front = 0
+
+    while (
+      front < runLength
+        && first + front < own.length
+        && open.every(court => usable(court, own[first + front]))
+    ) {
+      front++
+    }
+
+    // Nothing is lost during the run, or nothing is there to start with.
+    if (front === 0 || front === runLength) {
+      continue
+    }
+
+    const back = runLength - front
+    const length = front + 2 * back
+
+    if (first + length > own.length) {
+      continue
+    }
+
+    const remaining = own.slice(first + front, first + length)
+    const lasting = open.filter(court => remaining.every(slot => usable(court, slot)))
+    const capacity = Math.min(open.length, lasting.length * 2)
+
+    if (capacity <= sections[index].capacity) {
+      continue
+    }
+
+    return { index, first, front, back, length, capacity }
+  }
+
+  return null
+}
+
 /**
  * Group play for any shape whose groups run their whole round robin as
  * one unbroken stretch on one court - 5-team's ten matches over two
@@ -63,6 +167,7 @@ export function makeRunQueuePlanner() {
   const totalRunsByDivision = new Map()
 
   const nightSections = new Set()
+  const sharedByKey = new Map()
   const runLengthByDay = new Map()
 
   /**
@@ -91,7 +196,7 @@ export function makeRunQueuePlanner() {
    * @returns {Array<{date: string, count: number}>} the capacity the
    *   caller still has to account for, per date.
    */
-  function enqueue({ competition, group, dates, asFull = false }) {
+  function enqueue({ competition, group, dates, asFull = false, done = null }) {
     const teams = group.team_ids ?? []
     const size = group.pool_size ?? teams.length
 
@@ -139,7 +244,16 @@ export function makeRunQueuePlanner() {
       return needed
     }
 
-    for (const run of runs) {
+    for (const template of runs) {
+      // What is already in the plan is not owed again. A run with
+      // nothing left is dropped, and one part done is what remains of
+      // it, packed - on the day the template gave it.
+      const run = remainderOf(template, group.id, done)
+
+      if (run === null) {
+        continue
+      }
+
       // A template that spans two days needs two days to span. Where
       // the competition has only one, the group plays its whole round
       // robin that day rather than losing the half with nowhere to go
@@ -198,7 +312,7 @@ export function makeRunQueuePlanner() {
    * @param {Array} params.courts The courts these runs may use.
    * @param {Function} params.usable (court, slot) => boolean
    */
-  function prepare({ slotsFor, courts, usable }) {
+  function prepare({ slotsFor, courts, usable, sharing = false }) {
     for (const [key, queue] of groupRunQueue) {
       const date = key.slice(key.indexOf(':') + 1)
       const order = []
@@ -241,6 +355,18 @@ export function makeRunQueuePlanner() {
 
       const capacities = sections.map(section => section.capacity)
 
+      // Where courts are the limit, the section that loses courts part
+      // way through may hold more groups than it has courts for the
+      // whole run - see sharedSectionFor.
+      const shared = sharing
+        ? sharedSectionFor({ own, sections, runLength, courts, usable })
+        : null
+
+      if (shared) {
+        capacities[shared.index] = shared.capacity
+        sharedByKey.set(key, shared)
+      }
+
       for (const section of sections) {
         if (section.night) {
           nightSections.add(`${key}:${section.index}`)
@@ -261,10 +387,16 @@ export function makeRunQueuePlanner() {
       // The quota/band math itself is shared with every other planner
       // shape - see court-bands.mjs. Only the run-queue bookkeeping
       // (sections, lights, offsets) stays local to this planner.
+      const dates = [...groupRunQueue.keys()]
+        .filter(other => other.startsWith(`${competitionId}:`))
+        .map(other => other.slice(other.indexOf(':') + 1))
+        .sort()
+
       const { quotasBySection, bandsBySection } = computeSectionBands({
         divisions,
         totals,
         capacities,
+        rotation: dates.indexOf(date),
       })
 
       for (let section = 0; section < sectionCount; section++) {
@@ -304,7 +436,10 @@ export function makeRunQueuePlanner() {
     return sectionCountByDate.get(date) ?? 1
   }
 
-  function pick(competitionId, date, sectionIndex, court, { proCourt = false } = {}) {
+  function pick(
+    competitionId, date, sectionIndex, court,
+    { proCourt = false, strictQuota = false } = {}
+  ) {
     const queue = groupRunQueue.get(queueKey(competitionId, date))
 
     if (!queue || queue.length === 0) {
@@ -425,7 +560,8 @@ export function makeRunQueuePlanner() {
     // it for every group, so it only orders the choice.
     const wanted = owed.filter(entry => {
       const previous = previousSection(queue[entry.index].groupId, date)
-      return previous !== null && SECTION_OFFSET[previous] === sectionIndex
+      return previous !== null
+        && rotationTarget(previous, sectionCountFor(date)) === sectionIndex
     })
 
     // Failing the exact rotation, anything but the same section again.
@@ -440,6 +576,12 @@ export function makeRunQueuePlanner() {
     const wantedSet = new Set(wanted)
     const movedSet = new Set(moved)
 
+    // Asked to stay within the quotas, a division that has had its share
+    // here gets nothing more, spare room or not.
+    if (strictQuota && owed.length === 0) {
+      return { blocked: true }
+    }
+
     const best = owed.length > 0
       ? owed.reduce((a, b) => {
         // The band comes first, always - which court a division holds
@@ -599,5 +741,19 @@ export function makeRunQueuePlanner() {
     return (queue?.length ?? 0) > 0
   }
 
-  return { enqueue, prepare, pick, commit, previousSection, queued, hasQueued, runLengthFor }
+  /**
+   * The section, if any, whose run is played on shared courts.
+   *
+   * @param {number|string} competitionId
+   * @param {string} date
+   * @returns {?Object} see sharedSectionFor
+   */
+  function sharedFor(competitionId, date) {
+    return sharedByKey.get(queueKey(competitionId, date)) ?? null
+  }
+
+  return {
+    enqueue, prepare, pick, commit, previousSection, queued, hasQueued,
+    runLengthFor, sharedFor,
+  }
 }

package/lib/sessions.mjs

@@ -22,6 +22,40 @@ export function activePhase(sessions, date, hour) {
 
   return active
 }
+/**
+ * Which knockout rounds are on, as of this date and hour.
+ *
+ * A session may name them - "R32 and R16, the 11th, 09:00" - and then
+ * those are the only rounds that open from there, in the order the
+ * draws come down. A session that names none says nothing about
+ * rounds, and whatever the draws have left plays as it always did,
+ * which is every competition that has not been told otherwise.
+ *
+ * Read the same way as the phase: the last session to have started.
+ *
+ * @param {Array} sessions in date order
+ * @param {string} date
+ * @param {string} hour
+ * @returns {?Array<string>}
+ */
+export function activeRounds(sessions, date, hour) {
+  let active = null
+
+  for (const session of sessions) {
+    const started = session.date === date && session.start_time <= hour
+
+    if (session.date < date || started) {
+      const named = session.rounds ?? (session.round ? [session.round] : null)
+
+      active = named?.length ? named : null
+    } else {
+      break
+    }
+  }
+
+  return active
+}
+
 /**
  * The slots a competition runs on a date.
  *

package/lib/three-team-planner.mjs

@@ -114,9 +114,10 @@ function placeUnit({ unit, courts, slots, date, occupancy, darkFrom, blocks }) {
  * @param {Array<{id: number, teamIds: number[]}>} groups
  * @returns {Array<Array<{groupId: number, index: number}|null>>} slot by court
  */
-export function threeTeamUnitLayout(groups) {
+export function threeTeamUnitLayout(groups, done = null) {
   return unitLayout(groups, {
     template: GROUP_TEMPLATES[3],
     matchesFor: group => templateMatches({ teamIds: group.teamIds, groupSize: 3 }),
+    done,
   })
 }

package/package.json

@@ -40,5 +40,5 @@
   },
   "sideEffects": true,
   "type": "module",
-  "version": "0.0.2"
+  "version": "0.0.4"
 }