@@ -3458,6 +3625,7 @@ function renderEventManager(eventId) {
followUpSec: Math.max(0, Number(form.get("followUpSec") || 0) || 0),
startMode: String(form.get("startMode") || "mass"),
seedBestLapCount: Math.max(0, Number(form.get("seedBestLapCount") || 0) || 0),
+ seedMethod: String(form.get("seedMethod") || "best_sum"),
staggerGapSec: Math.max(0, Number(form.get("staggerGapSec") || 0) || 0),
maxCars: Number(form.get("maxCars") || 0) || null,
mode: event.mode,
@@ -3561,6 +3729,9 @@ function renderEventManager(eventId) {
editingSession.followUpSec = Math.max(0, Number(form.get("followUpSec") || 0) || 0);
editingSession.startMode = normalizeStartMode(String(form.get("startMode") || editingSession.startMode || "mass"));
editingSession.seedBestLapCount = Math.max(0, Number(form.get("seedBestLapCount") || 0) || 0);
+ editingSession.seedMethod = ["best_sum", "average", "consecutive"].includes(String(form.get("seedMethod") || "").toLowerCase())
+ ? String(form.get("seedMethod")).toLowerCase()
+ : "best_sum";
editingSession.staggerGapSec = Math.max(0, Number(form.get("staggerGapSec") || 0) || 0);
selectedSessionEditId = null;
saveState();
@@ -3771,7 +3942,17 @@ function renderEventManager(eventId) {
carsPerHeat: Math.max(2, Number(form.get("carsPerHeat") || 8) || 8),
qualDurationMin: Math.max(1, Number(form.get("qualDurationMin") || 5) || 5),
qualStartMode: normalizeStartMode(String(form.get("qualStartMode") || "staggered")),
+ qualSeedLapCount: Math.max(0, Number(form.get("qualSeedLapCount") || 2) || 0),
+ qualSeedMethod: ["best_sum", "average", "consecutive"].includes(String(form.get("qualSeedMethod") || "").toLowerCase())
+ ? String(form.get("qualSeedMethod")).toLowerCase()
+ : "best_sum",
countedQualRounds: Math.max(1, Number(form.get("countedQualRounds") || 1) || 1),
+ qualifyingPointsTable: ["rank_low", "field_desc", "ifmar"].includes(String(form.get("qualifyingPointsTable") || "").toLowerCase())
+ ? String(form.get("qualifyingPointsTable")).toLowerCase()
+ : "rank_low",
+ qualifyingTieBreak: ["rounds", "best_lap", "best_round"].includes(String(form.get("qualifyingTieBreak") || "").toLowerCase())
+ ? String(form.get("qualifyingTieBreak")).toLowerCase()
+ : "rounds",
carsPerFinal: Math.max(2, Number(form.get("carsPerFinal") || 8) || 8),
finalLegs: Math.max(1, Number(form.get("finalLegs") || 1) || 1),
countedFinalLegs: Math.max(1, Number(form.get("countedFinalLegs") || 1) || 1),
@@ -4480,6 +4661,30 @@ function renderGuide() {
+
@@ -5919,13 +6124,13 @@ function buildLeaderboard(session) {
isRollingPractice
? bestLapMs || lastLapMs || Number.MAX_SAFE_INTEGER
: useSeedRanking && seedMetric
- ? seedMetric.totalMs
+ ? seedMetric.comparableMs
: totalElapsedMs,
resultDisplay:
isRollingPractice
? formatLap(bestLapMs || lastLapMs)
: useSeedRanking && seedMetric
- ? `${seedMetric.lapCount}/${formatRaceClock(seedMetric.totalMs)}`
+ ? formatSeedMetric(seedMetric)
: `${Math.max(0, Number(row.laps || 0) + manualLapAdjustment)}/${formatRaceClock(totalElapsedMs)}`,
};
});
@@ -5941,8 +6146,8 @@ function buildLeaderboard(session) {
return (b.lastTimestamp || 0) - (a.lastTimestamp || 0);
}
if (useSeedRanking) {
- if (a.seedMetric && b.seedMetric && a.seedMetric.totalMs !== b.seedMetric.totalMs) {
- return a.seedMetric.totalMs - b.seedMetric.totalMs;
+ if (a.seedMetric && b.seedMetric && a.seedMetric.comparableMs !== b.seedMetric.comparableMs) {
+ return a.seedMetric.comparableMs - b.seedMetric.comparableMs;
}
if (a.seedMetric && !b.seedMetric) {
return -1;
@@ -6011,7 +6216,7 @@ function formatLeaderboardGap(row, referenceRow, options = {}) {
}
if (options.useSeedRanking) {
if (referenceRow.seedMetric && row.seedMetric) {
- const seedGap = Math.max(0, row.seedMetric.totalMs - referenceRow.seedMetric.totalMs);
+ const seedGap = Math.max(0, row.seedMetric.comparableMs - referenceRow.seedMetric.comparableMs);
return `+${(seedGap / 1000).toFixed(3)}s`;
}
return `+${Math.max(0, (referenceRow.laps || 0) - (row.laps || 0))}L`;
@@ -6150,6 +6355,55 @@ function formatRaceClock(ms) {
return `${m}:${s}.${centiseconds}:${millis}`;
}
+function getSeedMethodLabel(method) {
+ const normalized = ["best_sum", "average", "consecutive"].includes(String(method || "").toLowerCase())
+ ? String(method).toLowerCase()
+ : "best_sum";
+ return t(`events.seed_method_${normalized}`);
+}
+
+function formatSeedMetric(metric) {
+ if (!metric) {
+ return "-";
+ }
+ if (metric.method === "average") {
+ return `${metric.lapCount} avg ${formatLap(metric.averageMs)}`;
+ }
+ if (metric.method === "consecutive") {
+ return `${metric.lapCount} con ${formatRaceClock(metric.totalMs)}`;
+ }
+ return `${metric.lapCount}/${formatRaceClock(metric.totalMs)}`;
+}
+
+function getQualifyingPointsValue(place, fieldSize, tableType) {
+ const normalized = ["rank_low", "field_desc", "ifmar"].includes(String(tableType || "").toLowerCase())
+ ? String(tableType).toLowerCase()
+ : "rank_low";
+ if (normalized === "field_desc") {
+ return Math.max(1, Number(fieldSize || 0) - place + 1);
+ }
+ if (normalized === "ifmar") {
+ const scale = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+ return scale[place - 1] ?? 0;
+ }
+ return place;
+}
+
+function isHighPointsTable(tableType) {
+ return ["field_desc", "ifmar"].includes(String(tableType || "").toLowerCase());
+}
+
+function compareNumberSet(left, right, highWins = false) {
+ for (let i = 0; i < Math.max(left.length, right.length); i += 1) {
+ const leftValue = left[i] ?? (highWins ? -Infinity : Infinity);
+ const rightValue = right[i] ?? (highWins ? -Infinity : Infinity);
+ if (leftValue !== rightValue) {
+ return highWins ? rightValue - leftValue : leftValue - rightValue;
+ }
+ }
+ return 0;
+}
+
function getCompetitorElapsedMs(session, row) {
const startTs = Number(row?.startTimestamp || session?.startedAt || 0);
if (!startTs || !row?.lastTimestamp) {
@@ -6183,19 +6437,42 @@ function getCompetitorSeedMetric(session, row) {
return null;
}
+ const method = ["best_sum", "average", "consecutive"].includes(String(session?.seedMethod || "").toLowerCase())
+ ? String(session.seedMethod).toLowerCase()
+ : "best_sum";
const laps = getCompetitorPassings(session, row)
.map((passing) => Number(passing.lapMs || 0))
- .filter((lapMs) => lapMs > 500)
- .sort((a, b) => a - b);
+ .filter((lapMs) => lapMs > 500);
if (laps.length < lapCount) {
return null;
}
- const selected = laps.slice(0, lapCount);
+ let selected = [];
+ if (method === "consecutive") {
+ let bestWindow = null;
+ for (let index = 0; index <= laps.length - lapCount; index += 1) {
+ const window = laps.slice(index, index + lapCount);
+ const totalMs = window.reduce((sum, lapMs) => sum + lapMs, 0);
+ if (!bestWindow || totalMs < bestWindow.totalMs) {
+ bestWindow = { laps: window, totalMs };
+ }
+ }
+ if (!bestWindow) {
+ return null;
+ }
+ selected = bestWindow.laps;
+ } else {
+ selected = [...laps].sort((a, b) => a - b).slice(0, lapCount);
+ }
+ const totalMs = selected.reduce((sum, lapMs) => sum + lapMs, 0);
+ const averageMs = totalMs / lapCount;
return {
lapCount,
- totalMs: selected.reduce((sum, lapMs) => sum + lapMs, 0),
+ method,
+ totalMs,
+ averageMs,
+ comparableMs: method === "average" ? averageMs : totalMs,
laps: selected,
};
}
@@ -6248,7 +6525,7 @@ function buildPracticeStandings(event) {
buildLeaderboard(session).forEach((row) => {
const key = row.driverId || row.key;
const seedMetric = getCompetitorSeedMetric(session, row);
- const comparableMs = seedMetric?.totalMs ?? row.bestLapMs ?? row.totalElapsedMs;
+ const comparableMs = seedMetric?.comparableMs ?? row.bestLapMs ?? row.totalElapsedMs;
const current = competitorMap.get(key);
if (!current || comparableMs < current.comparableMs) {
competitorMap.set(key, {
@@ -6256,9 +6533,7 @@ function buildPracticeStandings(event) {
driverId: row.driverId,
driverName: row.driverName,
comparableMs,
- resultDisplay: seedMetric
- ? `${seedMetric.lapCount}/${formatRaceClock(seedMetric.totalMs)}`
- : `${row.laps}/${formatRaceClock(row.totalElapsedMs)}`,
+ resultDisplay: seedMetric ? formatSeedMetric(seedMetric) : `${row.laps}/${formatRaceClock(row.totalElapsedMs)}`,
sourceSessionName: session.name,
});
}
@@ -6276,6 +6551,9 @@ function buildQualifyingStandings(event) {
const sessions = getSessionsForEvent(event.id).filter((session) => session.type === "qualification");
const scoringMode = event.raceConfig?.qualifyingScoring || "points";
const countedRounds = Math.max(1, Number(event.raceConfig?.countedQualRounds || 1) || 1);
+ const pointsTable = event.raceConfig?.qualifyingPointsTable || "rank_low";
+ const highPointsWin = isHighPointsTable(pointsTable);
+ const tieBreak = event.raceConfig?.qualifyingTieBreak || "rounds";
const competitorMap = new Map();
sessions.forEach((session) => {
@@ -6290,13 +6568,17 @@ function buildQualifyingStandings(event) {
driverName: row.driverName,
points: [],
ranks: [],
- bestRoundMs: [],
+ roundMetrics: [],
+ bestLaps: [],
});
}
const entry = competitorMap.get(key);
- entry.points.push(index + 1);
+ entry.points.push(getQualifyingPointsValue(index + 1, entrantCount, pointsTable));
entry.ranks.push(index + 1);
- entry.bestRoundMs.push(row.totalElapsedMs);
+ entry.roundMetrics.push(row.comparisonMs);
+ if (Number.isFinite(row.bestLapMs)) {
+ entry.bestLaps.push(row.bestLapMs);
+ }
entry.bestResultDisplay = row.resultDisplay;
entry.lastSessionName = session.name;
entry.sessionCount = (entry.sessionCount || 0) + 1;
@@ -6305,45 +6587,60 @@ function buildQualifyingStandings(event) {
});
const rows = [...competitorMap.values()].map((entry) => {
- const sortedPoints = [...entry.points].sort((a, b) => a - b);
+ const sortedPoints = [...entry.points].sort((a, b) => (highPointsWin ? b - a : a - b));
const counted = sortedPoints.slice(0, countedRounds);
const totalScore = counted.reduce((sum, value) => sum + value, 0);
const bestRank = Math.min(...entry.ranks);
- const bestElapsed = Math.min(...entry.bestRoundMs);
+ const bestRoundMetric = Math.min(...entry.roundMetrics);
+ const bestSingleLapMs = entry.bestLaps.length ? Math.min(...entry.bestLaps) : Number.MAX_SAFE_INTEGER;
return {
key: entry.key,
driverId: entry.driverId,
driverName: entry.driverName,
ranks: [...entry.ranks].sort((a, b) => a - b),
+ countedPoints: counted,
totalScore,
bestRank,
- bestElapsed,
+ bestRoundMetric,
+ bestSingleLapMs,
score:
scoringMode === "points"
? `${totalScore} (${counted.join("+")})`
- : `${bestRank} / ${formatRaceClock(bestElapsed)}`,
+ : `${bestRank} / ${formatRaceClock(bestRoundMetric)}`,
};
});
rows.sort((a, b) => {
if (scoringMode === "points") {
if (a.totalScore !== b.totalScore) {
- return a.totalScore - b.totalScore;
+ return highPointsWin ? b.totalScore - a.totalScore : a.totalScore - b.totalScore;
}
- for (let i = 0; i < Math.max(a.ranks.length, b.ranks.length); i += 1) {
- const left = a.ranks[i] ?? 999;
- const right = b.ranks[i] ?? 999;
- if (left !== right) {
- return left - right;
- }
+ if (tieBreak === "best_lap" && a.bestSingleLapMs !== b.bestSingleLapMs) {
+ return a.bestSingleLapMs - b.bestSingleLapMs;
}
- return a.bestElapsed - b.bestElapsed;
+ if (tieBreak === "best_round" && a.bestRoundMetric !== b.bestRoundMetric) {
+ return a.bestRoundMetric - b.bestRoundMetric;
+ }
+ const pointDiff = compareNumberSet(a.countedPoints, b.countedPoints, highPointsWin);
+ if (pointDiff !== 0) {
+ return pointDiff;
+ }
+ return a.bestRoundMetric - b.bestRoundMetric;
}
if (a.bestRank !== b.bestRank) {
return a.bestRank - b.bestRank;
}
- return a.bestElapsed - b.bestElapsed;
+ if (tieBreak === "rounds") {
+ const rankDiff = compareNumberSet(a.ranks, b.ranks, false);
+ if (rankDiff !== 0) {
+ return rankDiff;
+ }
+ }
+ if (tieBreak === "best_lap" && a.bestSingleLapMs !== b.bestSingleLapMs) {
+ return a.bestSingleLapMs - b.bestSingleLapMs;
+ }
+ return a.bestRoundMetric - b.bestRoundMetric;
});
return rows.map((row, index) => ({
@@ -6713,6 +7010,10 @@ function generateQualifyingForRace(event) {
const carsPerHeat = Math.max(2, Number(event.raceConfig?.carsPerHeat || 8) || 8);
const qualDurationMin = Math.max(1, Number(event.raceConfig?.qualDurationMin || 5) || 5);
const qualStartMode = normalizeStartMode(event.raceConfig?.qualStartMode || "staggered");
+ const qualSeedLapCount = Math.max(0, Number(event.raceConfig?.qualSeedLapCount || 2) || 0);
+ const qualSeedMethod = ["best_sum", "average", "consecutive"].includes(String(event.raceConfig?.qualSeedMethod || "").toLowerCase())
+ ? String(event.raceConfig.qualSeedMethod).toLowerCase()
+ : "best_sum";
const followUpSec = Math.max(0, Number(event.raceConfig?.followUpSec || 0) || 0);
const heats = chunkArray(fallbackRows, carsPerHeat);
let created = 0;
@@ -6737,7 +7038,8 @@ function generateQualifyingForRace(event) {
followUpSec,
followUpStartedAt: null,
startMode: qualStartMode,
- seedBestLapCount: 2,
+ seedBestLapCount: qualSeedLapCount,
+ seedMethod: qualSeedMethod,
staggerGapSec: 3,
driverIds,
manualGridIds: [...driverIds],