Merge pull request #100 from SM-Obstacle/86-player-of-the-week

feat: player and map ranking ladder scores manager

Author: ahmadbky

Cargo.toml

@@ -11,6 +11,8 @@ members = [
   "crates/entity",
   "crates/graphql-api",
   "crates/graphql-schema-generator",
+  "crates/player-map-ranking",
+  "crates/compute-player-map-ranking",
 ]
 
 [workspace.dependencies]

crates/compute-player-map-ranking/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "compute-player-map-ranking"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+anyhow = { workspace = true }
+clap = { version = "4.5.48", features = ["derive"] }
+dotenvy = { workspace = true }
+mkenv = { workspace = true }
+player-map-ranking = { path = "../player-map-ranking" }
+records-lib = { path = "../records_lib" }
+sea-orm = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt", "rt-multi-thread"] }
+chrono = { workspace = true }
+
+[features]
+default = []
+mysql = ["records-lib/mysql"]
+postgres = ["records-lib/postgres"]

crates/compute-player-map-ranking/src/main.rs

@@ -0,0 +1,162 @@
+use std::{
+    cmp::Ordering,
+    fmt,
+    fs::{File, OpenOptions},
+    io::{self, Write},
+    path::Path,
+    str::FromStr,
+    time::Instant,
+};
+
+use anyhow::Context as _;
+use chrono::{DateTime, Days, Months, Utc};
+use clap::Parser as _;
+use mkenv::Env as _;
+use records_lib::{DbUrlEnv, time::Time};
+use sea_orm::Database;
+
+mkenv::make_env! {AppEnv includes [DbUrlEnv as db_env]:}
+
+#[derive(Clone)]
+struct SinceDuration {
+    date: DateTime<Utc>,
+}
+
+#[derive(Debug)]
+struct InvalidSinceDuration;
+
+impl fmt::Display for InvalidSinceDuration {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("invalid \"since duration\" argument")
+    }
+}
+
+impl std::error::Error for InvalidSinceDuration {}
+
+impl FromStr for SinceDuration {
+    type Err = InvalidSinceDuration;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let (n, unit) = s.split_at(s.len() - 1);
+        let n = n.parse::<u32>().map_err(|_| InvalidSinceDuration)?;
+        let now = Utc::now();
+        let date = match unit {
+            "d" => now - Days::new(n as _),
+            "w" => now - Days::new(n as u64 * 7),
+            "m" => now - Months::new(n),
+            "y" => now - Months::new(n * 12),
+            _ => return Err(InvalidSinceDuration),
+        };
+        Ok(Self { date })
+    }
+}
+
+#[derive(clap::Parser)]
+struct Args {
+    #[arg(
+        short = 'p',
+        long = "player-file",
+        default_value = "player_ranking.csv"
+    )]
+    player_ranking_file: String,
+    #[arg(short = 'm', long = "map-file", default_value = "map_ranking.csv")]
+    map_ranking_file: String,
+    #[arg(long = "since", value_parser = clap::value_parser!(SinceDuration))]
+    from_date: Option<SinceDuration>,
+}
+
+fn open_file<P: AsRef<Path>>(path: P) -> io::Result<File> {
+    OpenOptions::new()
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(path)
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let now = Instant::now();
+
+    dotenvy::dotenv().context("couldn't get environment file")?;
+    let args = Args::parse();
+
+    let mut player_ranking_file =
+        open_file(args.player_ranking_file).context("couldn't open player ranking output file")?;
+    let mut map_ranking_file =
+        open_file(args.map_ranking_file).context("couldn't open map ranking output file")?;
+
+    player_ranking_file
+        .write(b"id,login,name,score,player_link\n")
+        .context("couldn't write header to player ranking file")?;
+    map_ranking_file
+        .write(b"id,map_uid,name,score,average_score,min_record,")
+        .and_then(|_| {
+            map_ranking_file
+                .write(b"max_record,average_record,median_record,records_count,map_link\n")
+        })
+        .context("couldn't write header to map ranking file")?;
+
+    let db_url = AppEnv::try_get()
+        .context("couldn't initialize environment")?
+        .db_env
+        .db_url;
+    let db = Database::connect(db_url)
+        .await
+        .context("couldn't connect to database")?;
+
+    println!(
+        "Calculating scores{}...",
+        match &args.from_date {
+            Some(SinceDuration { date }) => format!(" since {}", date.format("%d/%m/%Y")),
+            None => "".to_owned(),
+        }
+    );
+
+    let scores = player_map_ranking::compute_scores(&db, args.from_date.map(|d| d.date))
+        .await
+        .context("couldn't compute the scores")?;
+
+    println!("Sorting them...");
+
+    let mut player_ranking = scores.player_scores.into_iter().collect::<Vec<_>>();
+    player_ranking.sort_by(|(_, a), (_, b)| b.partial_cmp(a).unwrap_or(Ordering::Equal));
+    let mut map_ranking = scores.map_scores.into_iter().collect::<Vec<_>>();
+    map_ranking.sort_by(|(_, a), (_, b)| b.partial_cmp(a).unwrap_or(Ordering::Equal));
+
+    println!("Writing to files...");
+
+    for (player, score) in player_ranking {
+        writeln!(
+            player_ranking_file,
+            "{},{login},{},{score},https://obstacle.titlepack.io/player/{login}",
+            player.inner.id,
+            player.inner.name,
+            login = player.inner.login,
+        )
+        .context("couldn't write a row to player ranking file")?;
+    }
+
+    for (map, score) in map_ranking {
+        writeln!(
+            map_ranking_file,
+            "{},{map_uid},{},{score},{},{},{},{},{},{},https://obstacle.titlepack.io/map/{map_uid}",
+            map.inner.id,
+            map.inner.name,
+            score / map.stats.records_count,
+            map.stats.min_record,
+            map.stats.max_record,
+            map.stats.average_record,
+            map.stats.median_record,
+            map.stats.records_count,
+            map_uid = map.inner.game_id,
+        )
+        .context("couldn't write a row to map ranking file")?;
+    }
+
+    println!(
+        "Finished. Time taken: {}",
+        Time(now.elapsed().as_millis() as _)
+    );
+
+    Ok(())
+}

crates/graphql-schema-generator/src/main.rs

@@ -11,7 +11,6 @@ use anyhow::Context as _;
 use clap::{Parser as _, ValueHint};
 
 #[derive(clap::Parser)]
-
 struct Args {
     #[arg(short, long, value_hint = ValueHint::DirPath)]
     directory: Option<String>,

crates/player-map-ranking/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "player-map-ranking"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+anyhow = { workspace = true }
+entity = { path = "../entity" }
+sea-orm = { workspace = true }
+
+[features]
+default = []
+mysql = ["sea-orm/sqlx-mysql"]
+postgres = ["sea-orm/sqlx-postgres"]

crates/player-map-ranking/src/lib.rs

@@ -0,0 +1,166 @@
+use std::{collections::HashMap, hash::Hash};
+
+use anyhow::Context as _;
+use entity::{global_records, maps, players};
+use sea_orm::{
+    ColumnTrait as _, ConnectionTrait, EntityTrait as _, QueryFilter as _, QueryOrder, QueryTrait,
+    sqlx::types::chrono::{DateTime, Utc},
+};
+
+#[derive(Default)]
+pub struct MapStats {
+    pub records_count: f64,
+    pub min_record: f64,
+    pub average_record: f64,
+    pub median_record: f64,
+    pub max_record: f64,
+}
+
+fn ms_to_sec(time: i32) -> f64 {
+    time as f64 / 1000.
+}
+
+fn compute_score(r: f64, rn: f64, t: f64, average_record: f64) -> f64 {
+    let record_score = (1000.0 * (rn * rn)).log10() + ((average_record - t).powi(2) + 1.0).log10();
+    record_score * ((rn / r) + 1.0).log10().powi(3)
+}
+
+pub struct HashablePlayer {
+    pub inner: players::Model,
+}
+
+impl Hash for HashablePlayer {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.inner.id.hash(state);
+    }
+}
+
+impl PartialEq for HashablePlayer {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner.id == other.inner.id
+    }
+}
+
+impl Eq for HashablePlayer {}
+
+pub struct HashableMap {
+    pub inner: maps::Model,
+    pub stats: MapStats,
+}
+
+impl Hash for HashableMap {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.inner.id.hash(state);
+    }
+}
+
+impl PartialEq for HashableMap {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner.id == other.inner.id
+    }
+}
+
+impl Eq for HashableMap {}
+
+pub struct Scores {
+    pub player_scores: HashMap<HashablePlayer, f64>,
+    pub map_scores: HashMap<HashableMap, f64>,
+}
+
+pub async fn compute_scores<C: ConnectionTrait>(
+    conn: &C,
+    from: Option<DateTime<Utc>>,
+) -> anyhow::Result<Scores> {
+    let mut maps = maps::Entity::find()
+        .all(conn)
+        .await
+        .context("couldn't retrieve all maps")?
+        .into_iter()
+        .map(|map| (map.id, map))
+        .collect::<HashMap<_, _>>();
+
+    let mut players = players::Entity::find()
+        .all(conn)
+        .await
+        .context("couldn't retrieve all players")?
+        .into_iter()
+        .map(|player| (player.id, player))
+        .collect::<HashMap<_, _>>();
+
+    let mut map_stats = HashMap::<u32, MapStats>::new();
+    let mut map_scores = HashMap::<u32, f64>::new();
+    let mut player_scores = HashMap::<u32, f64>::new();
+
+    for map in maps.values() {
+        let map_records = global_records::Entity::find()
+            .filter(global_records::Column::MapId.eq(map.id))
+            .apply_if(from, |query, from| {
+                query.filter(global_records::Column::RecordDate.gte(from))
+            })
+            .order_by_asc(global_records::Column::Time)
+            .all(conn)
+            .await
+            .with_context(|| format!("couldn't get records of map ID: {}", map.id))?;
+
+        if map_records.is_empty() {
+            continue;
+        }
+
+        let mut stats = MapStats {
+            records_count: map_records.len() as _,
+            min_record: ms_to_sec(map_records[0].time),
+            max_record: ms_to_sec(map_records[0].time),
+            ..Default::default()
+        };
+
+        for record in &map_records {
+            stats.min_record = stats.min_record.min(ms_to_sec(record.time));
+            stats.max_record = stats.max_record.max(ms_to_sec(record.time));
+            stats.average_record += ms_to_sec(record.time);
+        }
+
+        stats.average_record /= stats.records_count;
+        stats.median_record = ms_to_sec(map_records[map_records.len() / 2].time);
+
+        for (i, record) in map_records.iter().enumerate() {
+            let r = (i + 1) as f64;
+            let t = ms_to_sec(record.time).max(stats.average_record);
+            let score = compute_score(r, stats.records_count, t, stats.average_record);
+
+            let map_score = map_scores.entry(record.map_id).or_insert(0.);
+            let player_score = player_scores.entry(record.record_player_id).or_insert(0.);
+            *map_score += score;
+            *player_score += score;
+        }
+
+        map_stats.insert(map.id, stats);
+    }
+
+    let output = Scores {
+        player_scores: player_scores
+            .into_iter()
+            .map(|(player_id, score)| {
+                (
+                    HashablePlayer {
+                        inner: players.remove(&player_id).unwrap(),
+                    },
+                    score,
+                )
+            })
+            .collect(),
+        map_scores: map_scores
+            .into_iter()
+            .map(|(map_id, score)| {
+                (
+                    HashableMap {
+                        inner: maps.remove(&map_id).unwrap(),
+                        stats: map_stats.remove(&map_id).unwrap(),
+                    },
+                    score,
+                )
+            })
+            .collect(),
+    };
+
+    Ok(output)
+}