1use 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}