Skip to main content

lmu_shared_memory/
lib.rs

1//! # lmu-shared-memory
2//!
3//! Safe Rust interface for reading telemetry and standings
4//! from Le Mans Ultimate shared memory.
5//!
6//! ## Platform support
7//!
8//! This crate currently supports Windows only.
9//!
10//! ## Telemetry
11//!
12//! ```no_run
13//! use lmu_shared_memory::{LmuTelemetry, TelemetryUpdate};
14//!
15//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
16//! let mut telemetry = LmuTelemetry::connect()?;
17//!
18//! if let TelemetryUpdate::Snapshot(snapshot) = telemetry.read()? {
19//!     println!("Throttle: {}", snapshot.pedals.throttle);
20//! }
21//! # Ok(())
22//! # }
23//! ```
24//!
25//! ## Standings
26//!
27//! ```no_run
28//! use lmu_shared_memory::{LmuStandings, StandingsUpdate};
29//!
30//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
31//! let mut standings = LmuStandings::connect()?;
32//!
33//! if let StandingsUpdate::Snapshot(snapshot) = standings.read()? {
34//!     for entry in snapshot.entries {
35//!         println!(
36//!             "{}: {}",
37//!             entry.position,
38//!             entry.driver_name
39//!         );
40//!     }
41//! }
42//! # Ok(())
43//! # }
44//! ```
45
46use std::{cmp::Ordering, collections::HashMap};
47
48mod shared_memory;
49
50pub use shared_memory::{SharedMemory, SharedMemoryGuard, SharedMemoryLock};
51
52pub const MAPPING_NAME: &str = "LMU_Data";
53pub const MAPPING_SIZE: usize = 324_820;
54pub const MAX_VEHICLES: usize = 104;
55
56const MAX_READ_RETRIES: usize = 5;
57const STARTUP_EVENT: usize = 8;
58const SHUTDOWN_EVENT: usize = 12;
59const START_SESSION_EVENT: usize = 24;
60const SCORING_EVENT: usize = 40;
61const TELEMETRY_EVENT: usize = 44;
62const APPLICATION_WINDOW: usize = 72;
63const SCORING_INFO: usize = 1_632;
64const SCORING_TRACK_NAME: usize = SCORING_INFO;
65const SCORING_SESSION: usize = SCORING_INFO + 64;
66const SCORING_CURRENT_ET: usize = SCORING_INFO + 68;
67const SCORING_NUM_VEHICLES: usize = SCORING_INFO + 104;
68const SCORING_PLAYER_NAME: usize = SCORING_INFO + 116;
69const VEHICLE_SCORING: usize = 2_192;
70const VEHICLE_SCORING_SIZE: usize = 584;
71const ACTIVE_TELEMETRY_VEHICLES: usize = 128_464;
72const PLAYER_TELEMETRY_INDEX: usize = 128_465;
73const PLAYER_HAS_TELEMETRY: usize = 128_466;
74const VEHICLE_TELEMETRY: usize = 128_468;
75const VEHICLE_TELEMETRY_SIZE: usize = 1_888;
76
77const _: () = assert!(VEHICLE_TELEMETRY + VEHICLE_TELEMETRY_SIZE * MAX_VEHICLES == MAPPING_SIZE);
78
79#[derive(Debug)]
80pub enum Error {
81    UnsupportedPlatform,
82    SharedMemoryUnavailable {
83        name: String,
84        source: String,
85    },
86    MapViewFailed {
87        name: String,
88    },
89    OutOfBounds {
90        name: String,
91        offset: usize,
92        value_size: usize,
93        mapping_size: usize,
94    },
95}
96
97impl std::fmt::Display for Error {
98    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
99        match self {
100            Self::UnsupportedPlatform => {
101                write!(f, "LMU shared memory is only available on Windows")
102            }
103            Self::SharedMemoryUnavailable { name, source } => {
104                write!(f, "shared memory '{name}' is unavailable: {source}")
105            }
106            Self::MapViewFailed { name } => write!(f, "failed to map shared memory '{name}'"),
107            Self::OutOfBounds {
108                name,
109                offset,
110                value_size,
111                mapping_size,
112            } => write!(
113                f,
114                "read outside shared memory '{name}': {offset} + {value_size} > {mapping_size}"
115            ),
116        }
117    }
118}
119
120impl std::error::Error for Error {}
121
122pub type Result<T> = std::result::Result<T, Error>;
123
124trait Memory {
125    fn read<T: Copy>(&self, offset: usize) -> Result<T>;
126}
127
128impl Memory for SharedMemory {
129    fn read<T: Copy>(&self, offset: usize) -> Result<T> {
130        self.read(offset)
131    }
132}
133
134impl Memory for [u8] {
135    fn read<T: Copy>(&self, offset: usize) -> Result<T> {
136        let value_size = std::mem::size_of::<T>();
137        if offset
138            .checked_add(value_size)
139            .is_none_or(|end| end > self.len())
140        {
141            return Err(Error::OutOfBounds {
142                name: MAPPING_NAME.to_owned(),
143                offset,
144                value_size,
145                mapping_size: self.len(),
146            });
147        }
148        let pointer = unsafe { self.as_ptr().add(offset).cast::<T>() };
149        Ok(unsafe { pointer.read_unaligned() })
150    }
151}
152
153#[derive(Clone, Copy, Debug, Default, PartialEq)]
154pub struct PedalData {
155    pub throttle: f32,
156    pub brake: f32,
157    pub clutch: f32,
158}
159
160#[derive(Clone, Copy, Debug, Default, PartialEq)]
161pub struct TelemetrySnapshot {
162    pub pedals: PedalData,
163}
164
165#[derive(Clone, Copy, Debug, PartialEq)]
166pub enum TelemetryUpdate {
167    Snapshot(TelemetrySnapshot),
168    NoPlayer,
169    SourceAlive,
170    Unchanged,
171}
172
173#[derive(Clone, Copy, Debug, PartialEq, Eq)]
174struct TelemetryHeader {
175    event: u32,
176    active: u8,
177    player_index: u8,
178    has_player: u8,
179}
180
181#[derive(Default)]
182struct TelemetryState {
183    last_event: Option<u32>,
184    last_elapsed: Option<u64>,
185    had_player: bool,
186}
187
188pub struct LmuTelemetry {
189    mapping: SharedMemory,
190    lock: SharedMemoryLock,
191    state: TelemetryState,
192}
193
194impl LmuTelemetry {
195    pub fn connect() -> Result<Self> {
196        Ok(Self {
197            mapping: SharedMemory::open(MAPPING_NAME, MAPPING_SIZE)?,
198            lock: SharedMemoryLock::open()?,
199            state: TelemetryState::default(),
200        })
201    }
202
203    pub fn read(&mut self) -> Result<TelemetryUpdate> {
204        let Some(_guard) = self.lock.try_lock() else {
205            return Ok(TelemetryUpdate::Unchanged);
206        };
207        read_telemetry(&self.mapping, &mut self.state)
208    }
209}
210
211fn read_telemetry<M: Memory + ?Sized>(
212    memory: &M,
213    state: &mut TelemetryState,
214) -> Result<TelemetryUpdate> {
215    for _ in 0..MAX_READ_RETRIES {
216        let before = telemetry_header(memory)?;
217        let player = usize::from(before.player_index);
218        let base =
219            if before.has_player != 0 && player < usize::from(before.active).min(MAX_VEHICLES) {
220                Some(VEHICLE_TELEMETRY + player * VEHICLE_TELEMETRY_SIZE)
221            } else {
222                None
223            };
224        let Some(base) = base else {
225            let after = telemetry_header(memory)?;
226            if before != after {
227                continue;
228            }
229            let changed = state.last_event != Some(after.event) || state.had_player;
230            state.last_event = Some(after.event);
231            state.last_elapsed = None;
232            state.had_player = false;
233            return Ok(if changed {
234                TelemetryUpdate::NoPlayer
235            } else {
236                TelemetryUpdate::Unchanged
237            });
238        };
239        let elapsed_before = memory.read::<f64>(base + 12)?.to_bits();
240        let throttle = memory.read::<f64>(base + 388)?;
241        let brake = memory.read::<f64>(base + 396)?;
242        let clutch = memory.read::<f64>(base + 412)?;
243        let elapsed_after = memory.read::<f64>(base + 12)?.to_bits();
244        let after = telemetry_header(memory)?;
245        if before != after || elapsed_before != elapsed_after {
246            continue;
247        }
248        let first = state.last_event.is_none();
249        let source_updated = state.last_event != Some(after.event);
250        state.last_event = Some(after.event);
251        state.had_player = true;
252        if first || state.last_elapsed == Some(elapsed_after) {
253            state.last_elapsed = Some(elapsed_after);
254            return Ok(if source_updated || first {
255                TelemetryUpdate::SourceAlive
256            } else {
257                TelemetryUpdate::Unchanged
258            });
259        }
260        state.last_elapsed = Some(elapsed_after);
261        return Ok(TelemetryUpdate::Snapshot(TelemetrySnapshot {
262            pedals: PedalData {
263                throttle: normalize_input(throttle),
264                brake: normalize_input(brake),
265                clutch: normalize_input(clutch),
266            },
267        }));
268    }
269    Ok(TelemetryUpdate::Unchanged)
270}
271
272fn telemetry_header<M: Memory + ?Sized>(memory: &M) -> Result<TelemetryHeader> {
273    Ok(TelemetryHeader {
274        event: memory.read(TELEMETRY_EVENT)?,
275        active: memory.read(ACTIVE_TELEMETRY_VEHICLES)?,
276        player_index: memory.read(PLAYER_TELEMETRY_INDEX)?,
277        has_player: memory.read(PLAYER_HAS_TELEMETRY)?,
278    })
279}
280
281fn normalize_input(value: f64) -> f32 {
282    if value.is_finite() {
283        value.clamp(0., 1.) as f32
284    } else {
285        0.
286    }
287}
288
289#[derive(Clone, Debug, PartialEq, Eq, Hash)]
290pub struct VehicleKey {
291    pub id: i32,
292    pub vehicle_filename: String,
293    pub vehicle_name: String,
294}
295
296#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
297pub enum VehicleClass {
298    Hypercar,
299    Lmp2Elms,
300    Lmp2,
301    Lmp3,
302    Gte,
303    Lmgt3,
304    PaceCar,
305    #[default]
306    Unknown,
307}
308
309impl VehicleClass {
310    pub const ORDER: [Self; 8] = [
311        Self::Hypercar,
312        Self::Lmp2,
313        Self::Lmp2Elms,
314        Self::Lmp3,
315        Self::Gte,
316        Self::Lmgt3,
317        Self::PaceCar,
318        Self::Unknown,
319    ];
320    pub fn label(self) -> &'static str {
321        match self {
322            Self::Hypercar => "HYP",
323            Self::Lmp2Elms => "P2E",
324            Self::Lmp2 => "P2",
325            Self::Lmp3 => "P3",
326            Self::Gte => "GTE",
327            Self::Lmgt3 => "GT3",
328            Self::PaceCar => "SC",
329            Self::Unknown => "—",
330        }
331    }
332    pub fn name(self) -> &'static str {
333        match self {
334            Self::Hypercar => "Hypercar",
335            Self::Lmp2Elms => "LMP2 ELMS",
336            Self::Lmp2 => "LMP2",
337            Self::Lmp3 => "LMP3",
338            Self::Gte => "GTE",
339            Self::Lmgt3 => "LMGT3",
340            Self::PaceCar => "Pace Car",
341            Self::Unknown => "Unknown",
342        }
343    }
344}
345
346#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
347pub enum VehicleStatus {
348    #[default]
349    None,
350    PitRequested,
351    PitIn,
352    Pit,
353    PitOut,
354    Garage,
355    Finished,
356    Dnf,
357    Disqualified,
358}
359
360#[derive(Clone, Debug, Default, PartialEq, Eq)]
361pub struct TireCompound {
362    pub front: String,
363    pub rear: String,
364}
365
366impl TireCompound {
367    pub fn label(&self) -> String {
368        let front = compact_compound(&self.front);
369        let rear = compact_compound(&self.rear);
370        match (front, rear) {
371            (None, None) => "—".into(),
372            (Some(v), None) | (None, Some(v)) => v,
373            (Some(a), Some(b)) if a == b => a,
374            (Some(a), Some(b)) => format!("F:{a} R:{b}"),
375        }
376    }
377}
378
379#[derive(Clone, Debug, PartialEq)]
380pub struct StandingEntry {
381    pub key: VehicleKey,
382    pub driver_name: String,
383    pub vehicle_name: String,
384    pub vehicle_model: String,
385    pub class: VehicleClass,
386    pub position: u16,
387    pub class_position: u16,
388    pub laps: u16,
389    pub lap_distance: f64,
390    pub best_lap_ms: Option<u64>,
391    pub last_lap_ms: Option<u64>,
392    pub gap_to_leader_ms: Option<u64>,
393    pub laps_behind_leader: u16,
394    pub gap_to_previous_ms: Option<u64>,
395    pub laps_behind_previous: u16,
396    pub tires: TireCompound,
397    pub status: VehicleStatus,
398    pub penalties: u16,
399}
400
401#[derive(Clone, Debug, Default, PartialEq)]
402pub struct StandingsSnapshot {
403    pub session_generation: u64,
404    pub session: i32,
405    pub track_name: String,
406    pub focused_vehicle: Option<VehicleKey>,
407    pub entries: Vec<StandingEntry>,
408}
409
410#[derive(Clone, Debug, PartialEq)]
411pub enum StandingsUpdate {
412    Snapshot(StandingsSnapshot),
413    NoSession,
414    Unchanged,
415}
416
417#[derive(Default)]
418struct StandingsState {
419    startup: Option<u32>,
420    scoring: Option<u32>,
421    telemetry: Option<u32>,
422    elapsed: Option<u64>,
423    session_start: Option<u32>,
424    track: String,
425    session: i32,
426    generation: u64,
427    had_session: bool,
428}
429
430pub struct LmuStandings {
431    mapping: SharedMemory,
432    lock: SharedMemoryLock,
433    state: StandingsState,
434}
435
436impl LmuStandings {
437    pub fn connect() -> Result<Self> {
438        Ok(Self {
439            mapping: SharedMemory::open(MAPPING_NAME, MAPPING_SIZE)?,
440            lock: SharedMemoryLock::open()?,
441            state: StandingsState::default(),
442        })
443    }
444    pub fn read(&mut self) -> Result<StandingsUpdate> {
445        let Some(_guard) = self.lock.try_lock() else {
446            let window: u64 = self.mapping.read(APPLICATION_WINDOW)?;
447            if !shared_memory::source_window_alive(window) {
448                self.state.had_session = false;
449                return Err(Error::SharedMemoryUnavailable {
450                    name: MAPPING_NAME.into(),
451                    source: "source stopped while the shared lock was busy".into(),
452                });
453            }
454            return Ok(StandingsUpdate::Unchanged);
455        };
456        let frame = read_standings_frame(&self.mapping)?;
457        drop(_guard);
458        decode_standings(frame, &mut self.state)
459    }
460}
461
462struct RawEntry {
463    id: i32,
464    driver: [u8; 32],
465    vehicle: [u8; 64],
466    filename: [u8; 32],
467    class: [u8; 32],
468    laps: i16,
469    finish: u8,
470    distance: f64,
471    best: f64,
472    last: f64,
473    penalties: i16,
474    player: bool,
475    in_pits: bool,
476    place: u8,
477    behind_next: f64,
478    laps_next: i32,
479    behind_leader: f64,
480    laps_leader: i32,
481    pit: u8,
482    garage: bool,
483}
484
485struct RawTelemetry {
486    id: i32,
487    vehicle: [u8; 64],
488    front: [u8; 18],
489    rear: [u8; 18],
490    model: [u8; 30],
491    class: u8,
492}
493
494struct RawStandingsFrame {
495    startup: u32,
496    shutdown: u32,
497    session_start: u32,
498    scoring: u32,
499    telemetry_event: u32,
500    window: u64,
501    elapsed: f64,
502    session: i32,
503    track: [u8; 64],
504    player_name: [u8; 32],
505    player_telemetry_id: Option<i32>,
506    entries: Vec<RawEntry>,
507    telemetry: Vec<RawTelemetry>,
508}
509
510fn read_standings_frame<M: Memory + ?Sized>(memory: &M) -> Result<RawStandingsFrame> {
511    let startup = memory.read(STARTUP_EVENT)?;
512    let shutdown = memory.read(SHUTDOWN_EVENT)?;
513    let session_start = memory.read(START_SESSION_EVENT)?;
514    let scoring = memory.read(SCORING_EVENT)?;
515    let telemetry_event = memory.read(TELEMETRY_EVENT)?;
516    let window = memory.read(APPLICATION_WINDOW)?;
517    let elapsed = memory.read(SCORING_CURRENT_ET)?;
518    let session = memory.read(SCORING_SESSION)?;
519    let track = memory.read(SCORING_TRACK_NAME)?;
520    let player_name = memory.read(SCORING_PLAYER_NAME)?;
521    let count = memory
522        .read::<i32>(SCORING_NUM_VEHICLES)?
523        .clamp(0, MAX_VEHICLES as i32) as usize;
524    let telemetry_count =
525        usize::from(memory.read::<u8>(ACTIVE_TELEMETRY_VEHICLES)?).min(MAX_VEHICLES);
526    let player_index = usize::from(memory.read::<u8>(PLAYER_TELEMETRY_INDEX)?);
527    let has_player_telemetry = memory.read::<u8>(PLAYER_HAS_TELEMETRY)? != 0;
528    let entries = (0..count)
529        .map(|i| read_raw_entry(memory, VEHICLE_SCORING + i * VEHICLE_SCORING_SIZE))
530        .collect::<Result<Vec<_>>>()?;
531    let telemetry = (0..telemetry_count)
532        .map(|i| read_raw_telemetry(memory, VEHICLE_TELEMETRY + i * VEHICLE_TELEMETRY_SIZE))
533        .collect::<Result<Vec<_>>>()?;
534    let player_telemetry_id = has_player_telemetry
535        .then(|| telemetry.get(player_index).map(|entry| entry.id))
536        .flatten();
537    Ok(RawStandingsFrame {
538        startup,
539        shutdown,
540        session_start,
541        scoring,
542        telemetry_event,
543        window,
544        elapsed,
545        session,
546        track,
547        player_name,
548        player_telemetry_id,
549        entries,
550        telemetry,
551    })
552}
553
554fn read_raw_entry<M: Memory + ?Sized>(m: &M, base: usize) -> Result<RawEntry> {
555    Ok(RawEntry {
556        id: m.read(base)?,
557        driver: m.read(base + 4)?,
558        vehicle: m.read(base + 36)?,
559        laps: m.read::<i16>(base + 100)?,
560        finish: m.read(base + 103)?,
561        distance: m.read(base + 104)?,
562        best: m.read(base + 144)?,
563        last: m.read(base + 168)?,
564        penalties: m.read::<i16>(base + 194)?,
565        player: m.read::<u8>(base + 196)? != 0,
566        in_pits: m.read::<u8>(base + 198)? != 0,
567        place: m.read(base + 199)?,
568        class: m.read(base + 200)?,
569        behind_next: m.read(base + 232)?,
570        laps_next: m.read(base + 240)?,
571        behind_leader: m.read(base + 244)?,
572        laps_leader: m.read(base + 252)?,
573        pit: m.read(base + 457)?,
574        garage: m.read::<u8>(base + 507)? != 0,
575        filename: m.read(base + 544)?,
576    })
577}
578
579fn read_raw_telemetry<M: Memory + ?Sized>(m: &M, base: usize) -> Result<RawTelemetry> {
580    Ok(RawTelemetry {
581        id: m.read(base)?,
582        vehicle: m.read(base + 32)?,
583        front: m.read(base + 620)?,
584        rear: m.read(base + 638)?,
585        model: m.read(base + 796)?,
586        class: m.read(base + 826)?,
587    })
588}
589
590fn decode_standings(
591    frame: RawStandingsFrame,
592    state: &mut StandingsState,
593) -> Result<StandingsUpdate> {
594    if !frame.elapsed.is_finite() {
595        return Ok(StandingsUpdate::Unchanged);
596    }
597    let elapsed = frame.elapsed.to_bits();
598    let source_stopped = !shared_memory::source_window_alive(frame.window)
599        || (frame.shutdown > 0 && frame.shutdown >= frame.startup);
600    if source_stopped || frame.entries.is_empty() {
601        let changed = state.had_session
602            || state.startup != Some(frame.startup)
603            || state.scoring != Some(frame.scoring)
604            || state.elapsed != Some(elapsed);
605        state.startup = Some(frame.startup);
606        state.scoring = Some(frame.scoring);
607        state.telemetry = Some(frame.telemetry_event);
608        state.elapsed = Some(elapsed);
609        state.session_start = Some(frame.session_start);
610        state.had_session = false;
611        return Ok(if changed {
612            StandingsUpdate::NoSession
613        } else {
614            StandingsUpdate::Unchanged
615        });
616    }
617    if state.startup == Some(frame.startup)
618        && state.scoring == Some(frame.scoring)
619        && state.telemetry == Some(frame.telemetry_event)
620        && state.elapsed == Some(elapsed)
621        && state.session_start == Some(frame.session_start)
622    {
623        return Ok(StandingsUpdate::Unchanged);
624    }
625    let track = decode(&frame.track);
626    let restart = !state.had_session
627        || state.startup != Some(frame.startup)
628        || state.session_start != Some(frame.session_start)
629        || state.track != track
630        || state.session != frame.session
631        || (frame.session_start == 0
632            && state
633                .elapsed
634                .map(f64::from_bits)
635                .is_some_and(|old| frame.elapsed + 0.001 < old));
636    if restart {
637        state.generation = state.generation.wrapping_add(1).max(1);
638    }
639    state.startup = Some(frame.startup);
640    state.scoring = Some(frame.scoring);
641    state.telemetry = Some(frame.telemetry_event);
642    state.elapsed = Some(elapsed);
643    state.session_start = Some(frame.session_start);
644    state.track.clone_from(&track);
645    state.session = frame.session;
646    state.had_session = true;
647    let telemetry = frame
648        .telemetry
649        .into_iter()
650        .map(|entry| (entry.id, entry))
651        .collect::<HashMap<_, _>>();
652    let player_name = decode(&frame.player_name);
653    let mut official_focus = None;
654    let mut fallback_focus = None;
655    let mut entries = frame
656        .entries
657        .into_iter()
658        .map(|raw| {
659            let vehicle = decode(&raw.vehicle);
660            let filename = decode(&raw.filename);
661            let key = VehicleKey {
662                id: raw.id,
663                vehicle_filename: filename,
664                vehicle_name: vehicle.clone(),
665            };
666            let info = telemetry
667                .get(&raw.id)
668                .filter(|item| vehicle.eq_ignore_ascii_case(&decode(&item.vehicle)));
669            if raw.player && official_focus.is_none() {
670                official_focus = Some(key.clone());
671            }
672            if frame.player_telemetry_id == Some(raw.id)
673                && info.is_some()
674                && fallback_focus.is_none()
675            {
676                fallback_focus = Some(key.clone());
677            }
678            let class = info
679                .map(|item| class_from_code(item.class))
680                .filter(|class| *class != VehicleClass::Unknown)
681                .unwrap_or_else(|| class_from_name(&decode(&raw.class)));
682            StandingEntry {
683                key,
684                driver_name: decode(&raw.driver),
685                vehicle_name: vehicle,
686                vehicle_model: info.map(|item| decode(&item.model)).unwrap_or_default(),
687                class,
688                position: u16::from(raw.place),
689                class_position: 0,
690                laps: raw.laps.max(0) as u16,
691                lap_distance: raw.distance,
692                best_lap_ms: milliseconds(raw.best),
693                last_lap_ms: milliseconds(raw.last),
694                gap_to_leader_ms: milliseconds(raw.behind_leader),
695                laps_behind_leader: lap_gap(raw.laps_leader),
696                gap_to_previous_ms: milliseconds(raw.behind_next),
697                laps_behind_previous: lap_gap(raw.laps_next),
698                tires: TireCompound {
699                    front: info.map(|item| decode(&item.front)).unwrap_or_default(),
700                    rear: info.map(|item| decode(&item.rear)).unwrap_or_default(),
701                },
702                status: status(raw.finish, raw.pit, raw.in_pits, raw.garage),
703                penalties: raw.penalties.max(0) as u16,
704            }
705        })
706        .collect::<Vec<_>>();
707    entries.sort_by(|a, b| sort_entry(a, b, frame.session));
708    assign_positions_and_gaps(&mut entries, frame.session);
709    let focused_vehicle = official_focus
710        .or(fallback_focus)
711        .or_else(|| unique_driver_focus(&entries, &player_name));
712    Ok(StandingsUpdate::Snapshot(StandingsSnapshot {
713        session_generation: state.generation,
714        session: frame.session,
715        track_name: track,
716        focused_vehicle,
717        entries,
718    }))
719}
720
721fn sort_entry(a: &StandingEntry, b: &StandingEntry, session: i32) -> Ordering {
722    match (a.position > 0, b.position > 0) {
723        (true, true) => return a.position.cmp(&b.position),
724        (true, false) => return Ordering::Less,
725        (false, true) => return Ordering::Greater,
726        _ => {}
727    }
728    if (5..=8).contains(&session) {
729        a.best_lap_ms
730            .cmp(&b.best_lap_ms)
731            .then_with(|| a.key.id.cmp(&b.key.id))
732    } else {
733        b.laps
734            .cmp(&a.laps)
735            .then_with(|| {
736                b.lap_distance
737                    .partial_cmp(&a.lap_distance)
738                    .unwrap_or(Ordering::Equal)
739            })
740            .then_with(|| a.key.id.cmp(&b.key.id))
741    }
742}
743
744fn assign_positions_and_gaps(entries: &mut [StandingEntry], session: i32) {
745    let mut class_positions = HashMap::<VehicleClass, u16>::new();
746    let mut race_reference = HashMap::<VehicleClass, (u16, u64, u16, u64)>::new();
747    let mut qualifying_leader = HashMap::<VehicleClass, u64>::new();
748    if (5..=8).contains(&session) {
749        for entry in &*entries {
750            if let Some(best) = entry.best_lap_ms {
751                qualifying_leader
752                    .entry(entry.class)
753                    .and_modify(|leader| *leader = (*leader).min(best))
754                    .or_insert(best);
755            }
756        }
757    }
758    let mut qualifying_previous = HashMap::<VehicleClass, u64>::new();
759    for entry in entries {
760        let position = class_positions.entry(entry.class).or_default();
761        *position = position.saturating_add(1);
762        entry.class_position = *position;
763        if (5..=8).contains(&session) {
764            let previous = qualifying_previous.get(&entry.class).copied();
765            let leader = qualifying_leader.get(&entry.class).copied();
766            entry.gap_to_leader_ms = entry
767                .best_lap_ms
768                .zip(leader)
769                .map(|(lap, best)| lap.saturating_sub(best));
770            entry.gap_to_previous_ms = entry
771                .best_lap_ms
772                .zip(previous)
773                .map(|(lap, best)| lap.saturating_sub(best));
774            entry.laps_behind_leader = 0;
775            entry.laps_behind_previous = 0;
776            if let Some(best) = entry.best_lap_ms {
777                qualifying_previous.insert(entry.class, best);
778            }
779        } else {
780            let total_laps = entry.laps_behind_leader;
781            let total_gap = entry.gap_to_leader_ms.unwrap_or(0);
782            let reference = race_reference
783                .entry(entry.class)
784                .or_insert((total_laps, total_gap, total_laps, total_gap));
785            let leader_laps = total_laps.saturating_sub(reference.0);
786            let previous_laps = total_laps.saturating_sub(reference.2);
787            entry.gap_to_leader_ms =
788                (leader_laps == 0).then(|| total_gap.saturating_sub(reference.1));
789            entry.gap_to_previous_ms =
790                (previous_laps == 0).then(|| total_gap.saturating_sub(reference.3));
791            entry.laps_behind_leader = leader_laps;
792            entry.laps_behind_previous = previous_laps;
793            reference.2 = total_laps;
794            reference.3 = total_gap;
795        }
796    }
797}
798
799fn unique_driver_focus(entries: &[StandingEntry], player: &str) -> Option<VehicleKey> {
800    if player.is_empty() {
801        return None;
802    }
803    let mut matching = entries
804        .iter()
805        .filter(|entry| entry.driver_name.eq_ignore_ascii_case(player));
806    let first = matching.next()?;
807    matching.next().is_none().then(|| first.key.clone())
808}
809
810pub fn select_visible_entries(
811    entries: &[StandingEntry],
812    focused: Option<&VehicleKey>,
813    limit: usize,
814) -> Vec<StandingEntry> {
815    let limit = limit.max(1).min(entries.len());
816    if entries.len() <= limit {
817        return entries.to_vec();
818    }
819    let Some(index) = focused.and_then(|key| entries.iter().position(|entry| &entry.key == key))
820    else {
821        return entries[..limit].to_vec();
822    };
823    if index < 3 || limit <= 3 {
824        return entries[..limit].to_vec();
825    }
826    let local = limit - 3;
827    let start = index
828        .saturating_sub(local / 2)
829        .min(entries.len() - local)
830        .max(3);
831    entries[..3]
832        .iter()
833        .chain(entries[start..start + local].iter())
834        .cloned()
835        .collect()
836}
837
838pub fn select_class_blocks(
839    entries: &[StandingEntry],
840    focused: Option<&VehicleKey>,
841    limit: usize,
842    classes: &[VehicleClass],
843) -> Vec<(VehicleClass, Vec<StandingEntry>)> {
844    VehicleClass::ORDER
845        .into_iter()
846        .filter(|class| classes.contains(class))
847        .filter_map(|class| {
848            let members = entries
849                .iter()
850                .filter(|entry| entry.class == class)
851                .cloned()
852                .collect::<Vec<_>>();
853            (!members.is_empty()).then(|| (class, select_visible_entries(&members, focused, limit)))
854        })
855        .collect()
856}
857
858fn decode<const N: usize>(value: &[u8; N]) -> String {
859    let end = value.iter().position(|byte| *byte == 0).unwrap_or(N);
860    String::from_utf8_lossy(&value[..end]).trim().to_owned()
861}
862fn milliseconds(value: f64) -> Option<u64> {
863    (value.is_finite() && value > 0.)
864        .then(|| (value * 1000.).round())
865        .filter(|value| *value <= u64::MAX as f64)
866        .map(|value| value as u64)
867}
868fn lap_gap(value: i32) -> u16 {
869    value.clamp(0, u16::MAX as i32) as u16
870}
871fn class_from_code(value: u8) -> VehicleClass {
872    match value {
873        0 => VehicleClass::Hypercar,
874        2 => VehicleClass::Lmp2Elms,
875        3 => VehicleClass::Lmp2,
876        4 => VehicleClass::Lmp3,
877        5 => VehicleClass::Gte,
878        6 => VehicleClass::Lmgt3,
879        8 => VehicleClass::PaceCar,
880        _ => VehicleClass::Unknown,
881    }
882}
883fn class_from_name(value: &str) -> VehicleClass {
884    let value = value.to_ascii_lowercase();
885    if value.contains("hypercar") || value.contains("lmh") || value.contains("lmdh") {
886        VehicleClass::Hypercar
887    } else if value.contains("lmp2") && value.contains("elms") {
888        VehicleClass::Lmp2Elms
889    } else if value.contains("lmp2") {
890        VehicleClass::Lmp2
891    } else if value.contains("lmp3") {
892        VehicleClass::Lmp3
893    } else if value.contains("lmgt3") || value == "gt3" || value.contains(" gt3") {
894        VehicleClass::Lmgt3
895    } else if value.contains("gte") {
896        VehicleClass::Gte
897    } else if value.contains("pace") || value.contains("safety") {
898        VehicleClass::PaceCar
899    } else {
900        VehicleClass::Unknown
901    }
902}
903fn compact_compound(value: &str) -> Option<String> {
904    let value = value.trim();
905    if value.is_empty() {
906        return None;
907    }
908    let value_lower = value.to_ascii_lowercase();
909    let label = if value_lower.contains("soft") {
910        "S"
911    } else if value_lower.contains("medium") {
912        "M"
913    } else if value_lower.contains("hard") {
914        "H"
915    } else if value_lower.contains("wet") {
916        "W"
917    } else {
918        return Some(value.chars().take(6).collect());
919    };
920    Some(label.into())
921}
922fn status(finish: u8, pit: u8, in_pits: bool, garage: bool) -> VehicleStatus {
923    match finish {
924        3 => VehicleStatus::Disqualified,
925        2 => VehicleStatus::Dnf,
926        1 => VehicleStatus::Finished,
927        _ if garage => VehicleStatus::Garage,
928        _ => match pit {
929            1 => VehicleStatus::PitRequested,
930            2 => VehicleStatus::PitIn,
931            3 => VehicleStatus::Pit,
932            4 => VehicleStatus::PitOut,
933            _ if in_pits => VehicleStatus::Pit,
934            _ => VehicleStatus::None,
935        },
936    }
937}
938
939#[cfg(test)]
940mod tests {
941    use super::*;
942
943    #[test]
944    fn class_blocks_select_the_leader_and_focused_neighborhood() {
945        let entries = (1..=12)
946            .map(|position| StandingEntry {
947                key: VehicleKey {
948                    id: position,
949                    vehicle_filename: format!("{position}.veh"),
950                    vehicle_name: format!("Car {position}"),
951                },
952                driver_name: String::new(),
953                vehicle_name: String::new(),
954                vehicle_model: String::new(),
955                class: VehicleClass::Hypercar,
956                position: position as u16,
957                class_position: position as u16,
958                laps: 0,
959                lap_distance: 0.,
960                best_lap_ms: None,
961                last_lap_ms: None,
962                gap_to_leader_ms: None,
963                laps_behind_leader: 0,
964                gap_to_previous_ms: None,
965                laps_behind_previous: 0,
966                tires: TireCompound::default(),
967                status: VehicleStatus::None,
968                penalties: 0,
969            })
970            .collect::<Vec<_>>();
971        assert_eq!(
972            select_visible_entries(&entries, Some(&entries[8].key), 7)
973                .iter()
974                .map(|entry| entry.position)
975                .collect::<Vec<_>>(),
976            [1, 2, 3, 7, 8, 9, 10]
977        );
978    }
979
980    #[test]
981    fn tire_labels_are_compact() {
982        assert_eq!(
983            TireCompound {
984                front: "Medium".into(),
985                rear: "Hard".into()
986            }
987            .label(),
988            "F:M R:H"
989        );
990        assert_eq!(TireCompound::default().label(), "—");
991    }
992}