133 lines
5.8 KiB
JavaScript
133 lines
5.8 KiB
JavaScript
// Sponsor events (rental-kart style): guests drive the club's cars, several drivers share one
|
|
// car (and its transponder) across the day. The event stays a "track" event (its own tab), but
|
|
// its heats are ordinary race sessions plus carAssignments { driverId: carId }, so Race Day,
|
|
// qualifying standings, A/B finals and Start / Pause / Stop work as in a race.
|
|
// Guests are drivers with guestEventId: they are only shown inside their event.
|
|
import { splitIntoBalancedGroups } from "./event_race_logic.js";
|
|
|
|
export const isGuestDriver = (driver) => Boolean(driver?.guestEventId);
|
|
export const isSponsorEvent = (event) => event?.mode === "track" && Boolean(event?.sponsor);
|
|
|
|
// One name per line (or comma separated), duplicates and blanks dropped.
|
|
export function parseGuestNames(text) {
|
|
const seen = new Set();
|
|
return String(text || "").split(/[\n,;]+/).map((name) => name.trim().replace(/\s+/g, " ")).filter((name) => {
|
|
const key = name.toLowerCase();
|
|
if (!name || seen.has(key)) return false;
|
|
seen.add(key);
|
|
return true;
|
|
});
|
|
}
|
|
|
|
// 8 drivers, 4 cars -> 2 groups, 1 practice per group, 2 qualifying rounds, A and B finals.
|
|
export function defaultSponsorFormat(driverCount = 0, carCount = 0) {
|
|
const cars = Math.max(1, carCount);
|
|
return {
|
|
groups: Math.max(1, Math.ceil(Math.max(1, driverCount) / cars)),
|
|
practicePerGroup: 1, qualRounds: 2,
|
|
practiceMin: 3, qualMin: 4, finalMin: 5,
|
|
};
|
|
}
|
|
|
|
export function normalizeSponsorFormat(value = {}, driverCount = 0, carCount = 0) {
|
|
const base = defaultSponsorFormat(driverCount, carCount);
|
|
const int = (raw, fallback, min, max) => {
|
|
const number = Math.round(Number(raw));
|
|
return Number.isFinite(number) ? Math.max(min, Math.min(max, number)) : fallback;
|
|
};
|
|
return {
|
|
practicePerGroup: int(value.practicePerGroup, base.practicePerGroup, 0, 5),
|
|
qualRounds: int(value.qualRounds, base.qualRounds, 0, 6),
|
|
practiceMin: int(value.practiceMin, base.practiceMin, 1, 60),
|
|
qualMin: int(value.qualMin, base.qualMin, 1, 60),
|
|
finalMin: int(value.finalMin, base.finalMin, 1, 120),
|
|
groups: base.groups,
|
|
};
|
|
}
|
|
|
|
// Groups no bigger than the number of cars, as even as possible (9 drivers, 4 cars -> 3/3/3).
|
|
export function splitSponsorGroups(driverIds, carCount) {
|
|
return splitIntoBalancedGroups(driverIds, Math.max(1, carCount));
|
|
}
|
|
|
|
// Round r: driver i of the group gets car (i + r) mod cars, so everyone tries other cars.
|
|
export function rotateCars(driverIds, carIds, round) {
|
|
const map = {};
|
|
if (!carIds.length) return map;
|
|
driverIds.forEach((driverId, index) => { map[driverId] = carIds[(index + round) % carIds.length]; });
|
|
return map;
|
|
}
|
|
|
|
// Finals: cars drawn by lot.
|
|
export function drawCars(driverIds, carIds, random = Math.random) {
|
|
const pool = [...carIds];
|
|
for (let index = pool.length - 1; index > 0; index -= 1) {
|
|
const other = Math.floor(random() * (index + 1));
|
|
[pool[index], pool[other]] = [pool[other], pool[index]];
|
|
}
|
|
const map = {};
|
|
driverIds.forEach((driverId, index) => { if (pool[index]) map[driverId] = pool[index]; });
|
|
return map;
|
|
}
|
|
|
|
// The practice and qualifying heats as plain specs; the caller turns them into sessions.
|
|
// Names follow the race ones (Q1 H1 ...) so qualifying standings and Race Day order work.
|
|
export function planSponsorHeats(driverIds, carIds, format, { practiceLabel = "Practice" } = {}) {
|
|
const groups = splitSponsorGroups(driverIds, carIds.length);
|
|
const heats = [];
|
|
let round = 0;
|
|
for (let practice = 1; practice <= format.practicePerGroup; practice += 1, round += 1) {
|
|
groups.forEach((group, index) => heats.push({
|
|
name: `${practiceLabel} ${format.practicePerGroup > 1 ? `${practice} ` : ""}G${index + 1}`.trim(),
|
|
type: "practice", durationMin: format.practiceMin, driverIds: group, carAssignments: rotateCars(group, carIds, round),
|
|
}));
|
|
}
|
|
for (let qual = 1; qual <= format.qualRounds; qual += 1, round += 1) {
|
|
groups.forEach((group, index) => heats.push({
|
|
name: `Q${qual} H${index + 1}`, type: "qualification", durationMin: format.qualMin, driverIds: group, carAssignments: rotateCars(group, carIds, round),
|
|
}));
|
|
}
|
|
return heats;
|
|
}
|
|
|
|
// The race config the shared race code reads (heat and final size = number of cars).
|
|
export function sponsorRaceConfig(raceConfig, { driverIds, carIds, format }) {
|
|
return {
|
|
...raceConfig,
|
|
driverIds: [...driverIds],
|
|
participantsConfigured: true,
|
|
carsPerHeat: Math.max(2, carIds.length),
|
|
carsPerFinal: Math.max(2, carIds.length),
|
|
qualifyingRounds: Math.max(1, format.qualRounds),
|
|
qualDurationMin: format.qualMin,
|
|
finalDurationMin: format.finalMin,
|
|
qualifyingScoring: "best",
|
|
finalsSource: format.qualRounds > 0 ? "qualifying" : "practice",
|
|
finalLegs: 1,
|
|
bumpCount: 0,
|
|
reserveBumpSlots: false,
|
|
};
|
|
}
|
|
|
|
// Gives every session of the event without cars a draw (used after the finals are made).
|
|
export function drawCarsForSessions(sessions, carIds, random = Math.random) {
|
|
let count = 0;
|
|
sessions.forEach((session) => {
|
|
if (session.status !== "ready" || !Array.isArray(session.driverIds) || !session.driverIds.length) return;
|
|
if (session.carAssignments && Object.keys(session.carAssignments).length) return;
|
|
session.carAssignments = drawCars(session.driverIds, carIds, random);
|
|
count += 1;
|
|
});
|
|
return count;
|
|
}
|
|
|
|
// The driver a transponder belongs to in this heat: the one who drives the car with it.
|
|
export function findDriverByCarTransponder(session, cars, transponder) {
|
|
const assignments = session?.carAssignments;
|
|
if (!assignments || typeof assignments !== "object") return null;
|
|
const car = (cars || []).find((item) => String(item.transponder || "") === String(transponder || "") && Object.values(assignments).includes(item.id));
|
|
if (!car) return null;
|
|
const driverId = Object.keys(assignments).find((id) => assignments[id] === car.id);
|
|
return driverId ? { driverId, car } : null;
|
|
}
|