Files
Live_RC/src/series_logic.js
T

213 lines
11 KiB
JavaScript

import { orderSessionsForRunning } from "./event_race_logic.js";
// Series / cup: a set of races (events) scored together. Each event is one class, so a series
// with several classes gives one standings table per class. Pure functions - app.js feeds
// each event's day result (finishing order, from finals or else qualifying).
//
// Rules supported (see ROADMAP "Series / cup"):
// - points per place from a table, then a fixed step down to a minimum for later places;
// - who scores: every driver (open series), or only members of the series' club - others
// still race and appear in the day result, and members are re-ranked without them;
// - a driver with no registered lap in the event gets 0 points and no place;
// - count the best N results, or all completed events minus X (so a cancelled event
// reduces the count automatically);
// - ties: more wins among counted results, then 2nd places, 3rd..., then the latest common
// event where both scored, going backwards; otherwise a shared position.
export const SERIES_POINT_PRESETS = Object.freeze({
orc: { table: [100, 90, 82, 75, 69, 64, 60, 56, 52, 48], step: 4, min: 10 },
hundred: { table: [100, 80, 70, 60, 50, 45, 40, 35, 30, 25], step: 5, min: 5 },
f1: { table: [25, 18, 15, 12, 10, 8, 6, 4, 2, 1], step: 0, min: 0 },
});
const clampInt = (value, fallback, min = 0) => {
const number = Math.round(Number(value));
return Number.isFinite(number) && number >= min ? number : fallback;
};
export function parsePointsTable(text) {
return String(text || "")
.split(/[\s,;]+/)
.map((value) => Math.round(Number(value)))
.filter((value) => Number.isFinite(value) && value >= 0);
}
export function normalizeSeries(series = {}, { uid } = {}) {
const preset = SERIES_POINT_PRESETS.orc;
const table = Array.isArray(series.pointsTable) ? series.pointsTable.map((value) => clampInt(value, 0)) : preset.table.slice();
return {
id: String(series.id || (uid ? uid("series") : "")),
name: String(series.name || "").trim(),
club: String(series.club || "").trim(),
// "all" = every driver scores; "club" = only drivers whose club matches. Series saved before
// this choice existed keep their behaviour: a club filled in meant members only.
scoring: series.scoring === "club" || (series.scoring === undefined && String(series.club || "").trim()) ? "club" : "all",
classIds: Array.isArray(series.classIds) ? [...new Set(series.classIds.map(String).filter(Boolean))] : [],
eventIds: Array.isArray(series.eventIds) ? [...new Set(series.eventIds.map(String).filter(Boolean))] : [],
pointsTable: table.length ? table : preset.table.slice(),
pointsStep: clampInt(series.pointsStep, preset.step),
pointsMin: clampInt(series.pointsMin, preset.min),
countMode: series.countMode === "drop" ? "drop" : "best",
countValue: clampInt(series.countValue, series.countMode === "drop" ? 0 : 9),
createdAt: Number(series.createdAt) > 0 ? Number(series.createdAt) : Date.now(),
manualResults: normalizeManualResults(series.manualResults),
};
}
// A round's result set by hand (eventId -> driver ids, winner first), e.g. when the
// qualifying went wrong and the club decided the order itself.
function normalizeManualResults(value) {
const out = {};
if (!value || typeof value !== "object") return out;
Object.entries(value).forEach(([eventId, ids]) => {
const list = Array.isArray(ids) ? [...new Set(ids.map(String).filter(Boolean))] : [];
if (eventId && list.length) out[eventId] = list;
});
return out;
}
// The day result a round scores: the hand-set order when there is one, else the calculated.
export function getSeriesDayResult(series, eventId, calculated = [], getDriverName = () => "") {
const manual = series?.manualResults?.[eventId];
if (!manual?.length) return calculated;
return manual.map((driverId) => ({
driverId,
driverName: getDriverName(driverId) || calculated.find((row) => row.driverId === driverId)?.driverName || driverId,
hasLap: true,
manual: true,
}));
}
export function getSeriesPointsForPlace(series, place) {
const table = series.pointsTable || [];
if (!(place >= 1)) return 0;
if (place <= table.length) return table[place - 1];
// Step 0: every place after the table gets the minimum (F1: 0 from 11th).
if (!Number(series.pointsStep)) return Number(series.pointsMin || 0);
const last = table.length ? table[table.length - 1] : 0;
return Math.max(Number(series.pointsMin || 0), last - Number(series.pointsStep) * (place - table.length));
}
const sameClub = (club, seriesClub) => String(club || "").trim().toLowerCase() === String(seriesClub || "").trim().toLowerCase();
// dayResult: the event's finishing order, [{ driverId, driverName, hasLap }].
// Returns per-driver { place, points } for the drivers who score in this series.
export function scoreSeriesEvent(series, dayResult, { getDriverClub = () => "" } = {}) {
const scored = new Map();
let place = 0;
(dayResult || []).forEach((row) => {
if (!row?.driverId || scored.has(row.driverId)) return;
if (series.scoring === "club" && series.club && !sameClub(getDriverClub(row.driverId), series.club)) return;
if (!row.hasLap) {
scored.set(row.driverId, { place: null, points: 0, driverName: row.driverName });
return;
}
place += 1;
scored.set(row.driverId, { place, points: getSeriesPointsForPlace(series, place), driverName: row.driverName });
});
return scored;
}
export function getCountedResultsCount(series, completedEvents) {
if (series.countMode === "drop") return Math.max(Math.min(1, completedEvents), completedEvents - series.countValue);
return Math.min(series.countValue || completedEvents, completedEvents);
}
function compareTie(a, b, completedEventIds) {
const maxPlace = Math.max(0, ...a.countedPlaces, ...b.countedPlaces);
for (let place = 1; place <= maxPlace; place += 1) {
const diff = b.countedPlaces.filter((value) => value === place).length - a.countedPlaces.filter((value) => value === place).length;
if (diff) return diff;
}
for (let index = completedEventIds.length - 1; index >= 0; index -= 1) {
const left = a.byEvent.get(completedEventIds[index]);
const right = b.byEvent.get(completedEventIds[index]);
if (left?.place && right?.place && left.place !== right.place) return left.place - right.place;
}
return 0;
}
// events: the series' events (each { id, name, date, classId }), dayResults: Map eventId ->
// day result (empty/missing = not run yet). Returns one table per class.
export function buildSeriesStandings(series, { events = [], dayResults = new Map(), getDriverClub, getDriverName = () => "", classNames = new Map() } = {}) {
const inSeries = events
.filter((event) => series.eventIds.includes(event.id))
.sort((a, b) => String(a.date || "").localeCompare(String(b.date || "")) || String(a.name || "").localeCompare(String(b.name || "")));
const classIds = series.classIds.length ? series.classIds : [...new Set(inSeries.map((event) => event.classId))];
return classIds.map((classId) => {
const classEvents = inSeries.filter((event) => event.classId === classId);
const completed = classEvents.filter((event) => (dayResults.get(event.id) || []).length > 0);
const completedIds = completed.map((event) => event.id);
const counted = getCountedResultsCount(series, completed.length);
const drivers = new Map();
completed.forEach((event) => {
scoreSeriesEvent(series, dayResults.get(event.id), { getDriverClub }).forEach((result, driverId) => {
if (!drivers.has(driverId)) drivers.set(driverId, { driverId, driverName: getDriverName(driverId) || result.driverName || driverId, byEvent: new Map() });
drivers.get(driverId).byEvent.set(event.id, result);
});
});
const rows = [...drivers.values()].map((driver) => {
// Every completed event is a result; absence counts as 0 and can be struck.
const results = completed.map((event) => ({ eventId: event.id, ...(driver.byEvent.get(event.id) || { place: null, points: 0, absent: true }) }));
const keep = new Set([...results.keys()].sort((a, b) => results[b].points - results[a].points || a - b).slice(0, counted));
results.forEach((result, index) => { result.counted = keep.has(index); });
return {
driverId: driver.driverId,
driverName: driver.driverName,
results,
total: results.filter((result) => result.counted).reduce((sum, result) => sum + result.points, 0),
starts: results.filter((result) => !result.absent).length,
countedPlaces: results.filter((result) => result.counted && result.place).map((result) => result.place),
byEvent: driver.byEvent,
};
});
rows.sort((a, b) => b.total - a.total || compareTie(a, b, completedIds) || a.driverName.localeCompare(b.driverName));
rows.forEach((row, index) => {
const previous = rows[index - 1];
row.rank = previous && previous.total === row.total && compareTie(previous, row, completedIds) === 0 ? previous.rank : index + 1;
});
return {
classId,
className: classNames.get(classId) || classId,
events: classEvents.map((event) => ({ id: event.id, name: event.name, date: event.date, completed: completedIds.includes(event.id) })),
completedCount: completed.length,
countedCount: counted,
rows: rows.map(({ byEvent, countedPlaces, ...row }) => row),
};
});
}
// Where a round (one race) stands, from its sessions: not started -> qualifying created ->
// qualifying running -> qualifying done -> finals -> done.
export function getSeriesRoundStatus(sessions = []) {
const quals = sessions.filter((session) => session.type === "qualification");
const finals = sessions.filter((session) => session.type === "final");
const finished = (list) => list.length > 0 && list.every((session) => session.status === "finished");
const started = (list) => list.some((session) => ["running", "paused", "finished"].includes(session.status));
if (finals.length) return finished(finals) ? "done" : "finals";
if (!quals.length) return "not_started";
if (finished(quals)) return "qual_done";
return started(quals) ? "qual_running" : "qual_ready";
}
// The one thing to do next in a round, for the button on its row: run the seeding practice,
// make qualifying, run the next heat, make finals, run the next final. A session already
// running is shown first.
export function getSeriesRoundNextStep(sessions = []) {
const ordered = orderSessionsForRunning(sessions);
const live = ordered.find((session) => ["running", "paused"].includes(session.status));
if (live) return { kind: "live", session: live };
const ready = (type) => ordered.find((session) => session.type === type && session.status === "ready");
const has = (type) => ordered.some((session) => session.type === type);
if (!has("qualification")) {
const practice = ready("practice");
// notStarted: no seeding group has run yet (the groups can still be re-split).
const notStarted = ordered.filter((session) => session.type === "practice").every((session) => session.status === "ready");
return practice ? { kind: "seeding", session: practice, notStarted } : { kind: "make_qualifying" };
}
const heat = ready("qualification");
if (heat) return { kind: "qualifying", session: heat };
if (!has("final")) return { kind: "make_finals" };
const final = ready("final");
return final ? { kind: "final", session: final } : { kind: "done" };
}