213 lines
11 KiB
JavaScript
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" };
|
|
}
|