408 lines
11 KiB
Rust
408 lines
11 KiB
Rust
use std::{
|
|
ffi::{c_char, CStr},
|
|
sync::Arc,
|
|
};
|
|
|
|
use anyhow::Result;
|
|
use rfactor_sm_reader::{rF2VehicleTelemetry, VehicleScoringInfoV01};
|
|
use ui::prelude::*;
|
|
use utilities::prelude::Color;
|
|
|
|
use crate::overlay::{
|
|
rfactor_data::{DataReceiver, GamePhase},
|
|
UiOverlay,
|
|
};
|
|
use crate::write_log;
|
|
|
|
pub struct LeaderBoard {
|
|
gui_handler: Arc<GuiHandler>,
|
|
leaderboard: Arc<GuiBuilder>,
|
|
main_grid: Arc<Grid>,
|
|
|
|
entries: Vec<LeaderBoardEntry>,
|
|
|
|
entry_backgrounds: [Color; 2],
|
|
player_background: Color,
|
|
}
|
|
|
|
impl LeaderBoard {
|
|
const GRID: &str = include_str!("leaderboard_grid.xml");
|
|
const ENTRY: &str = include_str!("leaderboard_entry.xml");
|
|
|
|
pub fn new(gui_handler: &Arc<GuiHandler>) -> Result<Self> {
|
|
let gui = GuiBuilder::from_str(gui_handler, Self::GRID)?;
|
|
|
|
let main_grid = gui.element("main_grid")?;
|
|
|
|
Ok(Self {
|
|
gui_handler: gui_handler.clone(),
|
|
leaderboard: gui,
|
|
main_grid,
|
|
|
|
entries: Vec::new(),
|
|
|
|
entry_backgrounds: [Color::try_from("#838383")?, Color::try_from("#545454")?],
|
|
player_background: Color::try_from("#b4bf26")?,
|
|
})
|
|
}
|
|
|
|
fn c_char_to_string(c: [c_char; 32usize]) -> String {
|
|
unsafe { CStr::from_ptr(&c as *const c_char) }
|
|
.to_str()
|
|
.unwrap()
|
|
.to_string()
|
|
}
|
|
|
|
fn update_leaderboard<F>(
|
|
&mut self,
|
|
vehicle_scorings: &[VehicleScoringInfoV01],
|
|
f: F,
|
|
) -> Result<()>
|
|
where
|
|
F: Fn(&mut LeaderBoardEntry, &VehicleScoringInfoV01) -> Result<()>,
|
|
{
|
|
for vehicle_scoring in vehicle_scorings {
|
|
let driver_name = Self::c_char_to_string(vehicle_scoring.mDriverName);
|
|
|
|
// check driver list
|
|
match self
|
|
.entries
|
|
.iter_mut()
|
|
.find(|entry| vehicle_scoring.mID == entry.id())
|
|
{
|
|
Some(entry) => {
|
|
if entry.name() != driver_name {
|
|
entry.change_name(driver_name)?;
|
|
}
|
|
|
|
entry.update_place(vehicle_scoring.mPlace)?;
|
|
|
|
f(entry, vehicle_scoring)?;
|
|
}
|
|
None => {
|
|
let entry = LeaderBoardEntry::new(
|
|
&self.gui_handler,
|
|
vehicle_scoring.mID,
|
|
driver_name,
|
|
vehicle_scoring.mPlace,
|
|
{
|
|
let laps_behind = vehicle_scoring.mLapsBehindLeader;
|
|
|
|
if laps_behind != 0 {
|
|
BehindLeader::Laps(laps_behind)
|
|
} else {
|
|
BehindLeader::Time(vehicle_scoring.mTimeBehindLeader)
|
|
}
|
|
},
|
|
vehicle_scoring.mTimeBehindNext,
|
|
vehicle_scoring.mBestLapTime,
|
|
)?;
|
|
|
|
self.entries.push(entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
write_log!("create entries");
|
|
|
|
// check if entry count in grid is the same as the gathered entries
|
|
let force_update = if !self.entries.is_empty()
|
|
&& self
|
|
.main_grid
|
|
.child_at(0, self.entries.len() - 1)?
|
|
.is_none()
|
|
{
|
|
for i in 0..self.entries.len() {
|
|
self.main_grid.detach(0, i)?;
|
|
}
|
|
|
|
true
|
|
} else {
|
|
false
|
|
};
|
|
|
|
// check if any entry needs resorting
|
|
if force_update || self.entries.iter().any(|entry| entry.needs_resorting()) {
|
|
write_log!("leader board update required");
|
|
|
|
self.entries
|
|
.sort_by(|lhs, rhs| lhs.place().cmp(&rhs.place()));
|
|
|
|
for (i, entry) in self.entries.iter_mut().enumerate() {
|
|
entry.resorting_finished();
|
|
entry.change_background_color(self.entry_backgrounds[i % 2])?;
|
|
|
|
self.main_grid.attach(entry.snippet(), 0, i, 1, 1)?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn race_leaderboard(&mut self, vehicle_scorings: &[VehicleScoringInfoV01]) -> Result<()> {
|
|
self.update_leaderboard(vehicle_scorings, |entry, scoring| {
|
|
let laps_behind = scoring.mLapsBehindLeader;
|
|
|
|
if laps_behind != 0 {
|
|
entry.update_time_behind_leader(BehindLeader::Laps(laps_behind))
|
|
} else {
|
|
entry.update_time_behind_leader(BehindLeader::Time(scoring.mTimeBehindLeader))
|
|
}
|
|
})
|
|
}
|
|
|
|
fn quali_leaderboard(&mut self, vehicle_scorings: &[VehicleScoringInfoV01]) -> Result<()> {
|
|
self.update_leaderboard(vehicle_scorings, |entry, scoring| {
|
|
entry.update_best_lap(scoring.mBestLapTime)
|
|
})
|
|
}
|
|
}
|
|
|
|
impl UiOverlay for LeaderBoard {}
|
|
|
|
impl DataReceiver for LeaderBoard {
|
|
fn game_phase_change(&mut self, phase: GamePhase) -> Result<()> {
|
|
match phase {
|
|
GamePhase::Practice | GamePhase::Qualifying => {
|
|
for entry in self.entries.iter_mut() {
|
|
entry.update_best_lap(-1.0)?;
|
|
}
|
|
|
|
self.leaderboard.enable()?
|
|
}
|
|
|
|
GamePhase::Race => {
|
|
for entry in self.entries.iter_mut() {
|
|
entry.update_time_behind_leader(BehindLeader::Time(0.0))?;
|
|
}
|
|
|
|
self.leaderboard.enable()?;
|
|
}
|
|
_ => self.leaderboard.disable()?,
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn update_for_phase(&self, phase: GamePhase) -> bool {
|
|
match phase {
|
|
GamePhase::Practice | GamePhase::Qualifying | GamePhase::Race => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
fn scoring_update(
|
|
&mut self,
|
|
phase: GamePhase,
|
|
vehicle_scorings: &[VehicleScoringInfoV01],
|
|
) -> Result<()> {
|
|
write_log!("=================== leader board: scoring update ===================");
|
|
|
|
match phase {
|
|
GamePhase::Practice | GamePhase::Qualifying => {
|
|
self.quali_leaderboard(vehicle_scorings)?
|
|
}
|
|
|
|
GamePhase::Race => self.race_leaderboard(vehicle_scorings)?,
|
|
|
|
_ => (),
|
|
}
|
|
|
|
write_log!("leader board update finished");
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn telemetry_update(
|
|
&mut self,
|
|
player_id: Option<i32>,
|
|
_telemetries: &[rF2VehicleTelemetry],
|
|
) -> Result<()> {
|
|
if let Some(player_id) = player_id {
|
|
if let Some(entry) = self.entries.iter().find(|entry| entry.id() == player_id) {
|
|
entry.change_background_color(self.player_background)?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
|
|
enum BehindLeader {
|
|
Time(f64),
|
|
Laps(i32),
|
|
}
|
|
|
|
struct LeaderBoardEntry {
|
|
id: i32,
|
|
|
|
name: String,
|
|
place: u8,
|
|
behind: BehindLeader,
|
|
time_behind_next: f64,
|
|
best_lap: f64,
|
|
|
|
snippet: Arc<GuiSnippet>,
|
|
|
|
name_label: Arc<Label>,
|
|
place_label: Arc<Label>,
|
|
time_label: Arc<Label>,
|
|
|
|
place_updated: bool,
|
|
}
|
|
|
|
impl LeaderBoardEntry {
|
|
pub fn new(
|
|
gui_handler: &Arc<GuiHandler>,
|
|
id: i32,
|
|
name: String,
|
|
place: u8,
|
|
behind: BehindLeader,
|
|
time_behind_next: f64,
|
|
best_lap: f64,
|
|
) -> Result<Self> {
|
|
let snippet = GuiSnippet::from_str(gui_handler, LeaderBoard::ENTRY)?;
|
|
|
|
let name_label: Arc<Label> = snippet.element("name")?;
|
|
let place_label: Arc<Label> = snippet.element("place")?;
|
|
let time_label: Arc<Label> = snippet.element("time")?;
|
|
|
|
name_label.set_text(&name)?;
|
|
place_label.set_text(place)?;
|
|
time_label.set_text("---")?;
|
|
|
|
Ok(Self {
|
|
id,
|
|
|
|
name,
|
|
place,
|
|
behind,
|
|
time_behind_next,
|
|
best_lap,
|
|
|
|
snippet,
|
|
|
|
name_label,
|
|
place_label,
|
|
time_label,
|
|
|
|
place_updated: true,
|
|
})
|
|
}
|
|
|
|
pub fn id(&self) -> i32 {
|
|
self.id
|
|
}
|
|
|
|
pub fn place(&self) -> u8 {
|
|
self.place
|
|
}
|
|
|
|
pub fn name(&self) -> &str {
|
|
&self.name
|
|
}
|
|
|
|
pub fn change_name(&mut self, name: String) -> Result<()> {
|
|
self.name = name;
|
|
|
|
self.name_label.set_text(&self.name)
|
|
}
|
|
|
|
pub fn snippet(&self) -> Arc<GuiSnippet> {
|
|
self.snippet.clone()
|
|
}
|
|
|
|
pub fn change_background_color(&self, color: Color) -> Result<()> {
|
|
self.name_label.set_background(color)?;
|
|
self.place_label.set_background(color)?;
|
|
self.time_label.set_background(color)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn update_place(&mut self, place: u8) -> Result<()> {
|
|
if self.place != place {
|
|
self.place_updated = true;
|
|
}
|
|
|
|
self.place = place;
|
|
|
|
self.place_label.set_text(self.place)
|
|
}
|
|
|
|
pub fn update_time_behind_leader(&mut self, behind: BehindLeader) -> Result<()> {
|
|
if self.behind != behind {
|
|
self.behind = behind;
|
|
|
|
match self.behind {
|
|
BehindLeader::Time(time_behind) => {
|
|
// check if we are leader
|
|
if time_behind == 0.0 {
|
|
self.time_label.set_text("---")?;
|
|
} else {
|
|
let text = if time_behind > 60.0 {
|
|
let full_minutes = (self.best_lap / 60.0).floor();
|
|
let remainder = self.best_lap - (full_minutes * 60.0);
|
|
|
|
format!("+{:.0}:{:.0}", full_minutes, remainder)
|
|
} else {
|
|
format!("+{:.3}", time_behind)
|
|
};
|
|
|
|
self.time_label.set_text(text)?;
|
|
}
|
|
}
|
|
BehindLeader::Laps(laps_behind) => {
|
|
let text = if laps_behind == 1 {
|
|
format!("+{} Lap", laps_behind)
|
|
} else {
|
|
format!("+{} Laps", laps_behind)
|
|
};
|
|
|
|
self.time_label.set_text(text)?;
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn update_best_lap(&mut self, time: f64) -> Result<()> {
|
|
if self.best_lap != time {
|
|
self.best_lap = time;
|
|
|
|
if self.best_lap < 0.0 {
|
|
self.time_label.set_text("---")?;
|
|
} else {
|
|
let text = if self.best_lap > 60.0 {
|
|
let full_minutes = (self.best_lap / 60.0).floor();
|
|
let remainder = self.best_lap - (full_minutes * 60.0);
|
|
|
|
format!("{:.0}:{:.3}", full_minutes, remainder)
|
|
} else {
|
|
format!("{:.3}", self.best_lap)
|
|
};
|
|
|
|
self.time_label.set_text(text)?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn update_time_behind_next(&mut self, time: f64) -> Result<()> {
|
|
self.time_behind_next = time;
|
|
|
|
self.time_label
|
|
.set_text(format!("+{:.3}", self.time_behind_next))
|
|
}
|
|
|
|
pub fn needs_resorting(&self) -> bool {
|
|
self.place_updated
|
|
}
|
|
|
|
pub fn resorting_finished(&mut self) {
|
|
self.place_updated = false;
|
|
}
|
|
}
|