Files
Live_RC/src/race_audio.js
T

457 lines
27 KiB
JavaScript

import { PRACTICE_HYPE_EVENTS } from "./practice_hype_logic.js";
export const RACE_AUDIO_PRIORITIES = Object.freeze({ pass: 0, low: 10, normal: 20, high: 30, critical: 40 });
export const START_LIGHT_STATES = Object.freeze(["IDLE", "GRID", "READY", "LIGHT_1", "LIGHT_2", "LIGHT_3", "LIGHT_4", "LIGHT_5", "WAIT_RANDOM", "GO"]);
const event = (key, group, priority, voice = true, effect = "", cooldownMs = 0) => ({ key, group, priority, voice, effect, cooldownMs });
export const RACE_AUDIO_EVENT_DEFINITIONS = Object.freeze([
event("grid_open", "start", "normal"), event("grid_closed", "start", "normal"),
event("race_1_minute", "start", "normal"), event("race_30_seconds", "start", "normal"),
event("race_10_seconds", "start", "normal", true, "effects/warning.wav"),
event("drivers_ready", "start", "high"), event("start_sequence", "start", "high"),
event("start_tone", "start", "high", false, "effects/start_tone.wav"),
event("false_start", "start", "critical", true, "effects/warning.wav", 1000), event("restart_race", "start", "high"),
event("staggered_release", "start", "normal"),
event("prologue_start", "start", "normal"), event("prologue_minutes", "start", "normal"),
event("prologue_grid", "start", "high"), event("prologue_count", "start", "high"),
event("prologue_hold", "start", "high", true, "effects/warning.wav"), event("prologue_resumed", "start", "normal"),
event("prologue_cancelled", "start", "normal"), event("clock_running", "start", "high"),
event("heat_call", "start", "normal"),
event("transponder_pass", "race", "pass", false, "effects/transponder_pass.wav"), event("lap_completed", "race", "pass"),
event("personal_best", "race", "low", true, "effects/personal_best.wav", 1500),
event("fastest_lap", "race", "normal", true, "effects/fastest_lap_trophy.wav", 1500),
event("track_record", "race", "normal", true, "effects/track_record_fanfare.wav", 2000),
event("training_stable_pace", "training", "low", true, "", 120000),
event("new_leader", "race", "normal", true, "", 1000),
event("leader_update", "race", "normal"),
...PRACTICE_HYPE_EVENTS.map((key) => event(key, "training", "low")),
event("position_gain", "race", "low", false, "effects/position_gain.wav", 750),
event("position_loss", "race", "low", false, "effects/position_loss.wav", 750),
event("final_lap", "race", "high", true, "effects/final_lap.wav"),
event("one_minute_remaining", "race", "normal"), event("thirty_seconds_remaining", "race", "normal"),
event("ten_seconds_remaining", "race", "normal", true, "effects/warning.wav"),
event("time_expired", "race", "high", true, "effects/warning.wav"),
event("race_finished", "race", "high", true, "effects/finish_stop.wav"),
event("track_call", "control", "critical", true, "effects/warning.wav", 1000), event("track_clear", "control", "critical"),
event("yellow_flag", "control", "critical", true, "effects/warning.wav"), event("red_flag", "control", "critical", true, "effects/warning.wav"),
event("race_paused", "control", "critical", true, "effects/warning.wav"), event("race_resumed", "control", "high"),
event("marshal_warning", "control", "high", true, "effects/warning.wav", 1000), event("marshal_required", "control", "high", true, "effects/warning.wav", 1000),
event("penalty", "control", "high", true, "effects/warning.wav", 750), event("stop_and_go", "control", "high", true, "effects/warning.wav"),
event("drive_through", "control", "high", true, "effects/warning.wav"), event("disqualified", "control", "high", true, "effects/warning.wav"),
// EFRA 9.1-9.3: "Attention driver (name)" (blue flag) and an official warning (2 = DSQ).
event("driver_attention", "control", "high", true, "effects/warning.wav", 750), event("official_warning", "control", "high", true, "effects/warning.wav"),
event("pit_lane_open", "pit", "normal"), event("pit_lane_closed", "pit", "normal"),
event("entering_pits", "pit", "low", false, "effects/transponder_pass.wav"), event("leaving_pits", "pit", "low", false, "effects/transponder_pass.wav"),
event("pit_speed_warning", "pit", "high", true, "effects/warning.wav"),
event("qualifying_start", "qualifying", "high"), event("qualifying_remaining", "qualifying", "normal"),
event("qualifying_finished", "qualifying", "high", true, "effects/finish_stop.wav"), event("provisional_pole", "qualifying", "normal"),
event("pole_position", "qualifying", "normal", true, "effects/fastest_lap_trophy.wav"),
event("race_winner", "results", "high", true, "effects/fastest_lap_trophy.wav"), event("second_place", "results", "normal"),
event("third_place", "results", "normal"), event("podium", "results", "normal"),
event("heat_winner", "results", "high", true, "effects/fastest_lap_trophy.wav"), event("overall_winner", "results", "high", true, "effects/fastest_lap_trophy.wav"),
event("timing_connected", "system", "normal"), event("timing_disconnected", "system", "critical", true, "effects/warning.wav", 2000),
event("transponder_detected", "system", "pass", false, "effects/transponder_pass.wav"),
event("unknown_transponder", "system", "low", true, "effects/warning.wav", 2000), event("audio_test", "system", "normal", true, "effects/start_beep.wav"),
]);
const EVENT_BY_KEY = new Map(RACE_AUDIO_EVENT_DEFINITIONS.map((item) => [item.key, item]));
const DEFAULT_PASSING_SOUND = "effects/transponder_pass.wav";
const clamp = (value, fallback, min = 0, max = 1) => {
const number = Number(value);
return Math.max(min, Math.min(max, Number.isFinite(number) ? number : fallback));
};
// The start and finish signals can be chosen in Settings (the files are in the sound pack).
export const START_SOUNDS = Object.freeze({ tone: "effects/start_tone.wav", trumpet: "effects/start_trumpet.wav", horn: "effects/start_horn.wav", beep: "effects/start_beep.wav" });
export const FINISH_SOUNDS = Object.freeze({ stop: "effects/finish_stop.wav", fanfare: "effects/finish_fanfare.wav", horn: "effects/finish_horn.wav", classic: "effects/race_finish.wav" });
const FINISH_EVENTS = new Set(["race_finished", "qualifying_finished"]);
export function normalizeRaceAudioSettings(value = {}) {
const source = value && typeof value === "object" ? value : {};
const events = {};
RACE_AUDIO_EVENT_DEFINITIONS.forEach((definition) => {
const configured = source.events?.[definition.key] || {};
events[definition.key] = {
effect: Boolean(definition.effect) && configured.effect !== false,
voice: Boolean(definition.voice) && configured.voice !== false,
};
});
const minStartDelay = clamp(source.minStartDelay ?? source.start?.randomDelay?.min, 1, 0, 10);
const maxStartDelay = clamp(source.maxStartDelay ?? source.start?.randomDelay?.max, 4, minStartDelay, 10);
return {
enabled: source.enabled !== false,
muted: source.muted === true,
language: source.language === "en" ? "en" : "sv",
voiceUri: String(source.voiceUri || ""),
voiceRate: clamp(source.voiceRate, 1.08, 0.65, 1.35),
voicePitch: clamp(source.voicePitch, 0.9, 0.7, 1.3),
masterVolume: clamp(source.masterVolume ?? source.volume?.master, 0.8),
effectsVolume: clamp(source.effectsVolume ?? source.volume?.effects, 0.8),
voiceVolume: clamp(source.voiceVolume ?? source.volume?.voice, 0.9),
passingVolume: clamp(source.passingVolume ?? source.volume?.passing, 0.45),
startCountdownSeconds: [0, 10, 30, 60].includes(Number(source.startCountdownSeconds)) ? Number(source.startCountdownSeconds) : 0,
startLights: source.startLights !== false,
lightIntervalMs: Math.round(clamp(source.lightIntervalMs, 300, 100, 2000)),
randomStartDelay: source.randomStartDelay !== false,
minStartDelay,
maxStartDelay,
perCompetitorPassingTone: source.perCompetitorPassingTone === true,
startSound: Object.hasOwn(START_SOUNDS, source.startSound) ? source.startSound : "tone",
finishSound: Object.hasOwn(FINISH_SOUNDS, source.finishSound) ? source.finishSound : "stop",
raceCallouts: source.raceCallouts === "full" ? "full" : "passing",
// Practice hype calls (practice_hype_logic.js); never in qualifying or finals.
practiceHype: source.practiceHype !== false,
// Short lap time per passing, "Anders, 17 six": "practice" (default), "always" or "off".
lapTimeCalls: ["practice", "always", "off"].includes(source.lapTimeCalls) ? source.lapTimeCalls : "practice",
lapTimeCallName: source.lapTimeCallName === true,
// Qualifying and finals: "both" = when the leader changes and every 2 minutes,
// "change" = only when the leader changes, "off" = never (unless raceCallouts is "full").
raceLeaderCalls: ["off", "change", "both"].includes(source.raceLeaderCalls) ? source.raceLeaderCalls : "both",
// Practice: "new leader" is fun info for many, but nobody races anyone - it can be turned off.
practiceLeaderCalls: source.practiceLeaderCalls === "off" ? "off" : "on",
// Open Practice personal best calls (practice_callouts_logic.js); 0 turns a rule off.
practicePbWarmupLaps: Math.round(clamp(source.practicePbWarmupLaps, 10, 0, 30)),
practicePbCooldownSec: Math.round(clamp(source.practicePbCooldownSec, 60, 0, 600)),
practicePbMinGainMs: Math.round(clamp(source.practicePbMinGainMs, 100, 0, 2000)),
events,
templates: source.templates && typeof source.templates === "object" ? { ...source.templates } : {},
};
}
// During a race, timing systems give each passing its tone and nothing more: no names, no
// "personal best" / "new leader" calls per lap. raceCallouts "passing" (the default) keeps it
// that way for race sessions; "full" is the speaker mode. Practice always gets the full set,
// and the clock, start, final-lap and results calls are never affected.
export const RACE_PASSING_CALLOUT_EVENTS = Object.freeze(["personal_best", "fastest_lap", "track_record", "new_leader", "position_gain", "position_loss", "provisional_pole"]);
const PRACTICE_TYPES = new Set(["open_practice", "free_practice", "practice"]);
const PRACTICE_HYPE_SET = new Set(PRACTICE_HYPE_EVENTS);
export const LEADER_UPDATE_INTERVAL_MS = 120000;
export function isSilencedDuringRace(eventKey, settings, session) {
const audio = normalizeRaceAudioSettings(settings);
const practice = Boolean(session) && PRACTICE_TYPES.has(String(session.type || ""));
if (PRACTICE_HYPE_SET.has(eventKey)) return !practice || !audio.practiceHype;
if (eventKey === "lap_completed") return audio.lapTimeCalls === "off" || (audio.lapTimeCalls === "practice" && !practice);
if (practice && eventKey === "new_leader") return audio.practiceLeaderCalls === "off";
if (!session || practice) return false;
if (eventKey === "leader_update") return audio.raceLeaderCalls !== "both";
if (eventKey === "new_leader" && audio.raceLeaderCalls !== "off") return false;
if (audio.raceCallouts === "full") return false;
return RACE_PASSING_CALLOUT_EVENTS.includes(eventKey);
}
// The quick passing call used at race tracks: seconds and tenths, "17 six", "18 flat"
// ("17 sex", "18 jämnt"). Over a minute: "1 05 two".
const TENTHS = { en: ["flat", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"], sv: ["jämnt", "ett", "två", "tre", "fyra", "fem", "sex", "sju", "åtta", "nio"] };
export function formatShortLapCall(ms, language = "sv") {
const value = Math.max(0, Math.floor(Number(ms) || 0));
if (!value) return "";
const minutes = Math.floor(value / 60000);
const seconds = Math.floor((value % 60000) / 1000);
const tenth = TENTHS[language === "en" ? "en" : "sv"][Math.floor((value % 1000) / 100)];
return minutes ? `${minutes} ${String(seconds).padStart(2, "0")} ${tenth}` : `${seconds} ${tenth}`;
}
// A lap time as a speaker says it: seconds and hundredths as two numbers, "18 63" -> "18
// sixty-three" ("18 sextiotre"), not "0:18.630" or "18 point six three". Over a minute:
// "1 minut 05 32". Hundredths are cut, not rounded, as on the timing screens.
export function formatSpokenLapTime(ms, language = "sv") {
const value = Math.max(0, Math.floor(Number(ms) || 0));
if (!value) return "";
const minutes = Math.floor(value / 60000);
const seconds = Math.floor((value % 60000) / 1000);
// "00" would be read "hundred" by some voices: say "flat" / "jämnt" as on the passing call.
const cut = Math.floor((value % 1000) / 10);
const hundredths = cut ? String(cut).padStart(2, "0") : TENTHS[language === "en" ? "en" : "sv"][0];
if (!minutes) return `${seconds} ${hundredths}`;
const word = language === "en" ? (minutes === 1 ? "minute" : "minutes") : (minutes === 1 ? "minut" : "minuter");
return `${minutes} ${word} ${String(seconds).padStart(2, "0")} ${hundredths}`;
}
// A gap or other short time with a decimal mark: "0,30" (sv) / "0.30" (en), read as "zero
// point three zero" - a gap said as "0 30" would sound like a clock.
export function formatSpokenGap(ms, language = "sv") {
const value = Math.max(0, Math.floor(Number(ms) || 0));
if (!value) return "";
const minutes = Math.floor(value / 60000);
const sep = language === "en" ? "." : ",";
const seconds = `${Math.floor((value % 60000) / 1000)}${sep}${String(Math.floor((value % 1000) / 10)).padStart(2, "0")}`;
if (!minutes) return seconds;
return language === "en" ? `${minutes} ${minutes === 1 ? "minute" : "minutes"} ${seconds}` : `${minutes} ${minutes === 1 ? "minut" : "minuter"} ${seconds}`;
}
const joinUrl = (baseUrl, filePath) => `${String(baseUrl || "").replace(/\/+$/, "")}/${String(filePath || "").replace(/^\/+/, "")}`;
const interpolate = (template, variables = {}) => String(template || "").replace(/\{(\w+)\}/g, (_match, key) => String(variables[key] ?? ""));
function safeEffectPath(value) {
const clean = String(value || "").trim().replace(/\\/g, "/");
if (!clean || clean.includes("..") || clean.startsWith("/") || /^https?:/i.test(clean)) return "";
return clean.includes("/") ? clean : `effects/${clean}`;
}
function variantPlaybackRate(value) {
let hash = 0;
for (const char of String(value || "")) hash = ((hash << 5) - hash + char.charCodeAt(0)) | 0;
return 0.92 + (Math.abs(hash) % 17) / 100;
}
export function createRaceAudioEngine(options = {}) {
const manifestUrl = options.manifestUrl || "/race-sounds/sound_manifest.json";
const baseUrl = options.baseUrl || "/race-sounds/sounds";
const fetchImpl = options.fetchImpl || globalThis.fetch?.bind(globalThis);
const audioFactory = options.audioFactory || ((src) => new Audio(src));
const speak = options.speak || (() => false);
const getSettings = options.getSettings || (() => normalizeRaceAudioSettings());
const wait = options.wait || ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
const random = options.random || Math.random;
const now = options.now || Date.now;
const log = options.log || (() => {});
let manifestPromise = null;
let manifest = null;
let currentVoice = null;
let voiceSequence = 0;
let lightState = "IDLE";
let startSequenceGeneration = 0;
const voiceQueue = [];
const lightSubscribers = new Set();
const missingEffects = new Set();
const cooldowns = new Map();
async function loadManifest() {
if (manifest) return manifest;
if (!manifestPromise) manifestPromise = (async () => {
if (!fetchImpl) return null;
try {
const response = await fetchImpl(manifestUrl, { cache: "no-store" });
if (!response?.ok) return null;
manifest = await response.json();
return manifest;
} catch { return null; }
})();
return manifestPromise;
}
function configFor(key) {
const settings = normalizeRaceAudioSettings(getSettings());
return { settings, definition: EVENT_BY_KEY.get(key), configured: settings.events[key] || {} };
}
async function attemptEffect(effectPath, volume, playbackRate) {
if (!effectPath || missingEffects.has(effectPath)) return false;
try {
const audio = audioFactory(joinUrl(baseUrl, effectPath));
audio.volume = clamp(volume, 0.8);
if (playbackRate) audio.playbackRate = playbackRate;
const playback = audio.play();
if (playback?.then) await playback;
return true;
} catch {
missingEffects.add(effectPath);
return false;
}
}
async function playEffect(key, eventOptions = {}) {
const { settings, definition, configured } = configFor(key);
if (!settings.enabled || settings.muted || !configured.effect || !definition?.effect) return false;
await loadManifest();
const customPath = safeEffectPath(eventOptions.effectPath);
const chosen = key === "start_tone" ? START_SOUNDS[settings.startSound] : FINISH_EVENTS.has(key) ? FINISH_SOUNDS[settings.finishSound] : "";
const effectPath = customPath || chosen || safeEffectPath(manifest?.events?.[key]?.effect || definition.effect);
const isPassing = key === "transponder_pass" || key === "transponder_detected";
const volume = settings.masterVolume * (isPassing ? settings.passingVolume : settings.effectsVolume);
const rate = settings.perCompetitorPassingTone && isPassing && eventOptions.variant ? variantPlaybackRate(eventOptions.variant) : undefined;
const played = await attemptEffect(effectPath, volume, rate);
const fallbackRate = rate || (customPath && isPassing ? variantPlaybackRate(customPath) : undefined);
if (!played && customPath && isPassing) return attemptEffect(DEFAULT_PASSING_SOUND, volume, fallbackRate);
return played;
}
async function resolveVoice(key, eventOptions = {}) {
const { settings, definition, configured } = configFor(key);
if (!settings.enabled || settings.muted || !configured.voice || !definition?.voice) return null;
const loaded = await loadManifest();
const phraseKey = loaded?.events?.[key]?.voice || key;
const template = eventOptions.voiceText || settings.templates[key] || loaded?.voice_events?.[settings.language]?.[phraseKey] || "";
if (!template) return null;
return {
key,
text: interpolate(template, eventOptions.variables),
language: settings.language,
volume: settings.masterVolume * settings.voiceVolume,
priority: RACE_AUDIO_PRIORITIES[eventOptions.priority || definition.priority] ?? RACE_AUDIO_PRIORITIES.normal,
interrupt: eventOptions.interrupt === true || definition.priority === "critical",
};
}
function pumpVoiceQueue() {
if (currentVoice || !voiceQueue.length) return;
voiceQueue.sort((a, b) => b.priority - a.priority || a.sequence - b.sequence);
const task = voiceQueue.shift();
// A count-down call that could not be said on time is skipped: "8" after the start is wrong.
if (task.expiresAt && now() > task.expiresAt) { task.resolve(false); pumpVoiceQueue(); return; }
currentVoice = task;
Promise.resolve(speak(task.text, { language: task.language, volume: task.volume, interrupt: task.interrupt }))
.catch(() => false).finally(() => {
if (currentVoice === task) currentVoice = null;
task.resolve(true);
pumpVoiceQueue();
});
}
async function enqueueVoice(key, eventOptions = {}) {
const voice = await resolveVoice(key, eventOptions);
if (!voice) return false;
// Quick calls (the lap time per passing) are only said when the voice is free: a lap time
// said late is worse than none.
if (eventOptions.skipIfBusy && (currentVoice || voiceQueue.length)) return false;
return new Promise((resolve) => {
const group = String(eventOptions.group || "");
const task = { ...voice, group, sequence: voiceSequence += 1, resolve, expiresAt: eventOptions.maxDelayMs ? Number(eventOptions.queuedAt ?? now()) + Number(eventOptions.maxDelayMs) : 0 };
// A newer call in the same group (the count-down) replaces the older one instead of
// queueing behind it, so the voice never falls behind the clock.
if (group) {
dropQueuedGroup(group);
if (currentVoice?.group === group) {
currentVoice.resolve(false);
currentVoice = null;
task.interrupt = true;
}
}
if (task.interrupt && currentVoice && task.priority > currentVoice.priority) {
currentVoice.resolve(false);
currentVoice = null;
}
voiceQueue.push(task);
pumpVoiceQueue();
});
}
function dropQueuedGroup(group) {
for (let index = voiceQueue.length - 1; index >= 0; index -= 1) {
if (voiceQueue[index].group === group) voiceQueue.splice(index, 1)[0].resolve(false);
}
}
function isCoolingDown(key, eventOptions, definition) {
if (eventOptions.force) return false;
const cooldownMs = Number(eventOptions.cooldownMs ?? definition?.cooldownMs ?? 0);
if (!cooldownMs) return false;
const scope = `${key}:${eventOptions.scope || eventOptions.driverId || eventOptions.competitorKey || "global"}`;
const timestamp = now();
const previous = cooldowns.get(scope);
if (Number.isFinite(previous) && timestamp - previous < cooldownMs) return true;
cooldowns.set(scope, timestamp);
return false;
}
function trigger(key, eventOptions = {}) {
const definition = EVENT_BY_KEY.get(key);
if (!definition || isCoolingDown(key, eventOptions, definition)) return { effectDone: Promise.resolve(false), voiceDone: Promise.resolve(false) };
const effectDone = playEffect(key, eventOptions);
const queuedAt = now();
const voiceDone = effectDone.catch(() => false).then(() => enqueueVoice(key, { ...eventOptions, queuedAt }));
try { log({ timestamp: now(), event: key, audioFile: safeEffectPath(eventOptions.effectPath || definition.effect), priority: definition.priority, language: normalizeRaceAudioSettings(getSettings()).language, ...eventOptions.logData }); } catch { /* non-critical */ }
return { effectDone, voiceDone };
}
function emitLightState(nextState, details = {}) {
if (!START_LIGHT_STATES.includes(nextState)) return;
lightState = nextState;
lightSubscribers.forEach((listener) => { try { listener(nextState, details); } catch { /* UI-only */ } });
}
async function runStartSequence(session, callbacks = {}) {
const generation = ++startSequenceGeneration;
const cancelled = () => generation !== startSequenceGeneration;
const settings = normalizeRaceAudioSettings(getSettings());
if (!settings.enabled || settings.muted || callbacks.skipAudio) {
emitLightState("GO", { sessionId: session?.id });
callbacks.onTone?.();
return;
}
emitLightState("GRID", { sessionId: session?.id });
const flying = session?.startMode === "flying";
// Race Day's prologue replaces this count-down (skipCountdown); when the prologue ran all
// the way down it has also called 10..3, so the intro calls are skipped too (skipIntro).
if (!callbacks.skipCountdown) {
if (settings.startCountdownSeconds >= 60) { trigger("race_1_minute", { interrupt: true }); callbacks.onCountdown?.(60); await wait(30000); if (cancelled()) return false; }
if (settings.startCountdownSeconds >= 30) { trigger("race_30_seconds", { interrupt: true }); callbacks.onCountdown?.(30); await wait(20000); if (cancelled()) return false; }
if (settings.startCountdownSeconds >= 10) {
trigger("race_10_seconds", { interrupt: true });
for (let seconds = 10; seconds > 0; seconds -= 1) { callbacks.onCountdown?.(seconds); await wait(1000); if (cancelled()) return false; }
}
}
// A flying start has no start procedure (EFRA 9.2b): the horn and "clock is running" -
// each car's own clock then starts at its own first crossing.
if (flying) {
emitLightState("GO", { sessionId: session?.id });
await playEffect("start_tone", { force: true });
if (cancelled()) return false;
callbacks.onTone?.();
trigger("clock_running", { interrupt: true, logData: { sessionId: session?.id } });
return true;
}
emitLightState("READY", { sessionId: session?.id });
if (!callbacks.skipIntro) {
await trigger("drivers_ready", { interrupt: true }).voiceDone; if (cancelled()) return false;
if (session?.type === "qualification") await trigger("qualifying_start").voiceDone; if (cancelled()) return false;
await trigger("start_sequence").voiceDone; if (cancelled()) return false;
} else {
// After the count-down's "3": "Starting to the sound of the tone", like a timing system.
await trigger("start_sequence").voiceDone; if (cancelled()) return false;
}
// After that call it is quiet until the tone, 1-3 s later (IFMAR 4.2.6); the
// lights come on within that time. Otherwise: lights, then the random delay from settings.
const afterCountDown = Boolean(callbacks.skipIntro);
const windowMs = afterCountDown ? 1000 + random() * 2000 : 0;
const stepMs = afterCountDown ? Math.round(windowMs / (settings.startLights ? 6 : 1)) : settings.lightIntervalMs;
if (settings.startLights) {
for (let light = 1; light <= 5; light += 1) {
emitLightState(`LIGHT_${light}`, { sessionId: session?.id, lights: light });
callbacks.onLight?.(light);
await wait(stepMs); if (cancelled()) return false;
}
}
emitLightState("WAIT_RANDOM", { sessionId: session?.id });
const delaySeconds = afterCountDown ? stepMs / 1000
: settings.randomStartDelay
? settings.minStartDelay + random() * (settings.maxStartDelay - settings.minStartDelay)
: settings.minStartDelay;
callbacks.onArmed?.(delaySeconds);
await wait(Math.round(delaySeconds * 1000)); if (cancelled()) return false;
if (cancelled()) return false;
emitLightState("GO", { sessionId: session?.id });
await playEffect("start_tone", { force: true });
if (cancelled()) return false;
callbacks.onTone?.();
// Staggered heats don't release every car at once - the session is already live and
// recording by this point (each driver's own personal clock starts at their own first
// crossing regardless), this is purely the announcer calling cars out in grid order so
// marshals know who goes next, ~3s apart.
if (session?.startMode === "staggered" && Array.isArray(callbacks.staggerOrder) && callbacks.staggerOrder.length) {
for (let index = 0; index < callbacks.staggerOrder.length; index += 1) {
if (cancelled()) return false;
await trigger("staggered_release", { variables: { tp: callbacks.staggerOrder[index] }, scope: callbacks.staggerOrder[index], logData: { sessionId: session?.id, transponder: callbacks.staggerOrder[index] } }).voiceDone;
if (cancelled()) return false;
if (index < callbacks.staggerOrder.length - 1) { await wait(3000); if (cancelled()) return false; }
}
}
return true;
}
// The text a call would say, without saying it (to have Piper generate it ahead of time).
async function resolveText(key, variables = {}) {
const voice = await resolveVoice(key, { variables });
return voice ? { text: voice.text, language: voice.language } : null;
}
return {
loadManifest, playEffect, trigger, runStartSequence, resolveText,
subscribeStartLights(listener) { lightSubscribers.add(listener); listener(lightState, {}); return () => lightSubscribers.delete(listener); },
cancelStartSequence() { startSequenceGeneration += 1; emitLightState("IDLE"); },
dropVoiceGroup(group) { dropQueuedGroup(String(group || "")); },
resetStartLights() { emitLightState("IDLE"); },
getStartLightState: () => lightState,
getStatus: () => ({ loaded: Boolean(manifest), missingEffects: [...missingEffects], queuedVoices: voiceQueue.length, currentVoice: currentVoice?.key || "", lightState }),
};
}