feat: rework accuracy (#1)

counting past mistakes even after correcting them to provide more accurate accuracy (thanks @fuh-Q)

Author: Nirlep5252

src/main.rs

@@ -57,8 +57,15 @@ fn run(
                 // the paragraph isn't finished yet
                 let mut info = vec![];
                 if game.start_time.is_some() {
+                    let acc = game.accuracy();
+                    let acc_str = if acc.is_nan() {
+                        "ACC: --".to_string()
+                    } else {
+                        format!("ACC: {:.2}%", acc)
+                    };
+
                     info.push(format!("WPM: {:.2}", game.wpm()));
-                    info.push(format!("ACC: {:.2}%", game.accuracy()))
+                    info.push(acc_str);
                 } else {
                     info.push("WPM: --".to_string());
                     info.push("ACC: --".to_string());

src/typing.rs

@@ -1,10 +1,9 @@
 pub mod typing {
-    use rand_word;
     use ratatui::{
         style::{Color, Style},
         text::Span,
     };
-    use std::time::SystemTime;
+    use std::{collections::HashSet, time::SystemTime};
 
     #[derive(Debug)]
     pub struct TypingGame {
@@ -13,51 +12,69 @@ pub mod typing {
         pub start_time: Option<SystemTime>,
         pub end_time: Option<SystemTime>,
         pub word_count: usize,
+        pub mistakes: u32,
+        pub mistake_indices: HashSet<usize>,
     }
 
     impl TypingGame {
         pub fn new(words: usize) -> Self {
             let mut goal = rand_word::new(words);
+            let cap = goal.len();
+
             while goal.contains("º") {
                 goal = rand_word::new(words);
             }
+
             TypingGame {
                 goal,
                 current: "".to_string(),
                 start_time: None,
                 end_time: None,
                 word_count: words,
+                mistakes: 0,
+                mistake_indices: HashSet::with_capacity(cap),
             }
         }
 
         pub fn reset(&mut self) {
             self.current = "".to_string();
             self.start_time = None;
+
+            self.mistake_indices.clear();
+            self.mistakes = 0;
         }
 
         pub fn new_goal(&mut self) {
             self.goal = TypingGame::new(self.word_count).goal;
         }
 
-        pub fn accuracy(&self) -> f64 {
+        pub fn accuracy(&mut self) -> f32 {
             let mut correct_count = 0;
             let goal_chars = self.goal.chars().collect::<Vec<char>>();
 
             for (i, ch) in self.current.char_indices() {
                 if goal_chars[i] == ch {
                     correct_count += 1;
+                } else if !self.mistake_indices.contains(&i) {
+                    self.mistakes += 1;
+                    self.mistake_indices.insert(i);
                 }
             }
-            correct_count as f64 * 100f64 / self.current.len() as f64
+
+            let correct = u32::checked_sub(correct_count, self.mistakes).unwrap_or(0);
+
+            // average correctly typed characters + correct but PREVIOUSLY incorrect characters
+            // then change it into a percentage
+            ((correct + correct_count) as f32 / 2f32 * 100f32) as f32 / self.current.len() as f32
         }
 
-        pub fn wpm(&self) -> f64 {
-            self.current.split_whitespace().count() as f64
+        pub fn wpm(&self) -> f32 {
+            self.current.split_whitespace().count() as f32
                 / (SystemTime::now()
                     .duration_since(self.start_time.unwrap())
                     .unwrap()
-                    .as_secs_f64()
-                    / 60f64)
+                    .as_secs_f32()
+                    / 60f32)
         }
 
         pub fn curr_spans(&self) -> Vec<Span> {