Track each user stat for marines, aliens and in total

Track wins, score, hits, misses

ns2-stat-cli/src/main.rs

@@ -29,11 +29,12 @@ struct CliArgs {
 
 struct UserRow {
     name: String,
-    kills: u32,
-    assists: u32,
-    deaths: u32,
     kd: f32,
     kda: f32,
+    games: u32,
+    commander: u32,
+    avg_score: f32,
+    accuracy: f32,
 }
 
 struct MapRow {
@@ -47,14 +48,15 @@ fn print_stats(stats: NS2Stats) {
         .users
         .into_iter()
         .filter_map(|(name, user)| {
-            if user.total_games > 2 {
+            if user.games.total > 2 {
                 Some(UserRow {
                     name,
-                    kills: user.kills,
-                    assists: user.assists,
-                    deaths: user.deaths,
-                    kd: user.kd(),
-                    kda: user.kda(),
+                    kd: user.kd().total,
+                    kda: user.kda().total,
+                    games: user.games.total,
+                    commander: user.commander.total,
+                    avg_score: user.average_score().total,
+                    accuracy: user.accuracy().total,
                 })
             } else {
                 None
@@ -63,24 +65,26 @@ fn print_stats(stats: NS2Stats) {
         .collect::<Vec<_>>();
     users.sort_by_key(|user| -(user.kd * 100f32) as i32);
     table::print_table(
-        ["NAME", "KILLS", "ASSISTS", "DEATHS", "KD", "KDA"],
+        ["NAME", "KD", "KDA", "GAMES", "COMMANDER", "AVG SCORE", "ACCURACY"],
         [
             Alignment::Left,
             Alignment::Right,
             Alignment::Right,
             Alignment::Right,
             Alignment::Right,
             Alignment::Right,
+            Alignment::Right,
         ],
         &users,
         |UserRow {
              name,
-             kills,
-             assists,
-             deaths,
              kd,
              kda,
-         }| row!["{name}", "{kills}", "{assists}", "{deaths}", "{kd:.2}", "{kda:.2}"],
+             games,
+             commander,
+             avg_score,
+             accuracy,
+         }| row!["{name}", "{kd:.2}", "{kda:.2}", "{games}", "{commander}", "{avg_score:.2}", "{accuracy:.2}"],
     );
 
     println!("\n\n");

ns2-stat-cli/src/table.rs

@@ -1,6 +1,6 @@
 #[macro_export]
 macro_rules! row {
-    ($($e:literal),*) => {
+    ($($e:literal),*$(,)?) => {
         [$(format!($e)),*]
     }
 }

ns2-stat/src/lib.rs

@@ -1,8 +1,9 @@
 use std::collections::HashMap;
+use std::ops::AddAssign;
 
 use serde::Serialize;
 
-use input_types::{GameStats, WinningTeam};
+use input_types::{GameStats, Team, WinningTeam};
 
 pub mod input_types;
 
@@ -47,24 +48,66 @@ impl<'a, I: Iterator<Item = &'a GameStats>> Games<'a, I> {
     }
 }
 
+// can be used for games, commander, wins, kills, deaths, assists
+#[derive(Clone, Copy, Default, Serialize)]
+pub struct Stat<T> {
+    pub total: T,
+    pub marines: T,
+    pub aliens: T,
+}
+
+impl<T: AddAssign + Copy> Stat<T> {
+    fn add(&mut self, team: Team, n: T) {
+        self.total += n;
+        match team {
+            Team::Aliens => self.aliens += n,
+            Team::Marines => self.marines += n,
+        }
+    }
+}
+
+impl<T: Copy> Stat<T> {
+    fn map<const N: usize, U>(stats: [Stat<T>; N], f: impl Fn([T; N]) -> U) -> Stat<U> {
+        Stat {
+            total: f(stats.map(|stat| stat.total)),
+            marines: f(stats.map(|stat| stat.marines)),
+            aliens: f(stats.map(|stat| stat.aliens)),
+        }
+    }
+}
+
 #[derive(Default, Serialize)]
 pub struct User {
-    pub total_games: u32,
-    pub commander: u32,
-    pub marines: u32,
-    pub aliens: u32,
-    pub kills: u32,
-    pub assists: u32,
-    pub deaths: u32,
+    /// The number of games played.
+    pub games: Stat<u32>,
+    /// The number of games played as commander.
+    pub commander: Stat<u32>,
+    pub wins: Stat<u32>,
+    pub kills: Stat<u32>,
+    pub assists: Stat<u32>,
+    pub deaths: Stat<u32>,
+    pub score: Stat<u32>,
+    pub hits: Stat<u32>,
+    pub misses: Stat<u32>,
 }
 
 impl User {
-    pub fn kd(&self) -> f32 {
-        self.kills as f32 / self.deaths as f32
+    /// `kills / deaths`
+    pub fn kd(&self) -> Stat<f32> {
+        Stat::map([self.kills, self.deaths], |[kills, deaths]| kills as f32 / deaths as f32)
     }
 
-    pub fn kda(&self) -> f32 {
-        (self.kills + self.assists) as f32 / self.deaths as f32
+    /// `(kills + assists) / deaths`
+    pub fn kda(&self) -> Stat<f32> {
+        Stat::map([self.kills, self.assists, self.deaths], |[kills, assists, deaths]| (kills + assists) as f32 / deaths as f32)
+    }
+
+    pub fn average_score(&self) -> Stat<f32> {
+        Stat::map([self.games, self.score], |[games, score]| score as f32 / games as f32)
+    }
+
+    pub fn accuracy(&self) -> Stat<f32> {
+        Stat::map([self.hits, self.misses], |[hits, misses]| hits as f32 / (hits + misses) as f32)
     }
 }
 
@@ -105,35 +148,41 @@ impl NS2Stats {
                     Some(user) => user,
                     None => users.entry(player_stat.player_name.clone()).or_insert_with(User::default),
                 };
-                user.total_games += 1;
-
-                for stats in [&player_stat.marines, &player_stat.aliens] {
-                    user.kills += stats.kills;
-                    user.assists += stats.assists;
-                    user.deaths += stats.deaths;
-                }
 
-                if player_stat.marines.time_played > player_stat.aliens.time_played {
+                let (team, stats) = if player_stat.marines.time_played > player_stat.aliens.time_played {
                     // player was in marine team
-                    user.marines += 1;
+                    if game.round_info.winning_team == WinningTeam::Marines {
+                        user.wins.add(Team::Marines, 1);
+                    }
                     if player_stat.marines.commander_time > marine_comm_time {
                         marine_comm = &player_stat.player_name;
                         marine_comm_time = player_stat.marines.commander_time;
                     }
+                    (Team::Marines, &player_stat.marines)
                 } else {
                     // player was in alien team
-                    user.aliens += 1;
+                    if game.round_info.winning_team == WinningTeam::Aliens {
+                        user.wins.add(Team::Aliens, 1);
+                    }
                     if player_stat.aliens.commander_time > alien_comm_time {
                         alien_comm = &player_stat.player_name;
                         alien_comm_time = player_stat.aliens.commander_time;
                     }
-                }
+                    (Team::Aliens, &player_stat.aliens)
+                };
+                user.games.add(team, 1);
+                user.kills.add(team, stats.kills);
+                user.assists.add(team, stats.assists);
+                user.deaths.add(team, stats.deaths);
+                user.score.add(team, stats.score);
+                user.hits.add(team, stats.hits);
+                user.misses.add(team, stats.misses);
             }
             if let Some(user) = users.get_mut(marine_comm) {
-                user.commander += 1;
+                user.commander.add(Team::Marines, 1);
             }
             if let Some(user) = users.get_mut(alien_comm) {
-                user.commander += 1;
+                user.commander.add(Team::Aliens, 1);
             }
 
             let map_entry = match maps.get_mut(&game.round_info.map_name) {