refactor: split scoring system into calculator/tracker pattern

- Extract TotalCalculator from TotalTracker for separation of concerns
- Add SessionCalculator to compute session-level metrics
- Create dedicated ScoreCalculator for score calculation logic
- Move trackers to dedicated tracker/ subdirectory
- Remove obsolete engine.rs and scoring system tests

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: unhappychoice

src/scoring/calculator/mod.rs

@@ -0,0 +1,9 @@
+pub mod realtime;
+pub mod session;
+pub mod stage;
+pub mod total;
+
+pub use realtime::{RealTimeCalculator, RealTimeResult};
+pub use session::SessionCalculator;
+pub use stage::StageCalculator;
+pub use total::TotalCalculator;

src/scoring/calculator/realtime.rs

@@ -0,0 +1,35 @@
+use std::time::Duration;
+
+/// Real-time metric calculation
+pub struct RealTimeCalculator;
+
+impl RealTimeCalculator {
+    pub fn calculate(
+        current_position: usize,
+        mistakes: usize,
+        elapsed_time: Duration,
+    ) -> RealTimeResult {
+        let elapsed_secs = elapsed_time.as_secs_f64().max(0.1);
+        let cpm = (current_position as f64 / elapsed_secs) * 60.0;
+        let wpm = cpm / 5.0;
+        let accuracy = if current_position > 0 {
+            ((current_position.saturating_sub(mistakes)) as f64 / current_position as f64) * 100.0
+        } else {
+            0.0
+        };
+
+        RealTimeResult {
+            wpm,
+            cpm,
+            accuracy,
+            mistakes,
+        }
+    }
+}
+
+pub struct RealTimeResult {
+    pub wpm: f64,
+    pub cpm: f64,
+    pub accuracy: f64,
+    pub mistakes: usize,
+}

src/scoring/calculator/session.rs

@@ -0,0 +1,153 @@
+use crate::models::SessionResult;
+use crate::scoring::tracker::SessionTracker;
+use std::time::Duration;
+
+/// Session level result calculation
+pub struct SessionCalculator;
+
+impl SessionCalculator {
+    /// Calculate session result using SessionTracker data only
+    pub fn calculate(tracker: &SessionTracker) -> SessionResult {
+        let data = tracker.get_data();
+
+        // Calculate valid session duration (completed stages only)
+        let valid_session_duration: Duration = data
+            .stage_results
+            .iter()
+            .filter(|sr| !sr.was_skipped && !sr.was_failed)
+            .map(|sr| sr.completion_time)
+            .sum();
+
+        // Calculate invalid session duration (skipped/failed stages)
+        let invalid_session_duration: Duration = data
+            .stage_results
+            .iter()
+            .filter(|sr| sr.was_skipped || sr.was_failed)
+            .map(|sr| sr.completion_time)
+            .sum();
+
+        // Total session duration for backward compatibility
+        let session_duration = valid_session_duration + invalid_session_duration;
+
+        // Calculate metrics from stage_results
+        let stages_completed = data
+            .stage_results
+            .iter()
+            .filter(|sr| !sr.was_skipped && !sr.was_failed)
+            .count();
+
+        let stages_skipped = data
+            .stage_results
+            .iter()
+            .filter(|sr| sr.was_skipped)
+            .count();
+
+        let stages_attempted = data.stage_results.len();
+
+        let valid_keystrokes: usize = data
+            .stage_results
+            .iter()
+            .filter(|sr| !sr.was_skipped && !sr.was_failed)
+            .map(|sr| sr.keystrokes)
+            .sum();
+
+        let valid_mistakes: usize = data
+            .stage_results
+            .iter()
+            .filter(|sr| !sr.was_skipped && !sr.was_failed)
+            .map(|sr| sr.mistakes)
+            .sum();
+
+        // Calculate session score from valid keystrokes and mistakes
+        let session_score = if valid_keystrokes > 0 {
+            let elapsed_secs = valid_session_duration.as_secs_f64().max(0.1);
+            let cpm = (valid_keystrokes as f64 / elapsed_secs) * 60.0;
+            let accuracy = ((valid_keystrokes.saturating_sub(valid_mistakes)) as f64
+                / valid_keystrokes as f64)
+                * 100.0;
+
+            crate::scoring::ScoreCalculator::calculate_score_from_metrics(
+                cpm,
+                accuracy,
+                valid_mistakes,
+                elapsed_secs,
+                valid_keystrokes,
+            )
+        } else {
+            0.0
+        };
+
+        // Find best and worst stage by challenge_score
+        let best_stage = data.stage_results.iter().max_by(|a, b| {
+            a.challenge_score
+                .partial_cmp(&b.challenge_score)
+                .unwrap_or(std::cmp::Ordering::Equal)
+        });
+
+        let worst_stage = data.stage_results.iter().min_by(|a, b| {
+            a.challenge_score
+                .partial_cmp(&b.challenge_score)
+                .unwrap_or(std::cmp::Ordering::Equal)
+        });
+
+        let best_stage_wpm = best_stage.map(|s| s.wpm).unwrap_or(0.0);
+        let best_stage_accuracy = best_stage.map(|s| s.accuracy).unwrap_or(0.0);
+        let worst_stage_wpm = worst_stage.map(|s| s.wpm).unwrap_or(0.0);
+        let worst_stage_accuracy = worst_stage.map(|s| s.accuracy).unwrap_or(0.0);
+
+        // Session is successful if no stage failed
+        let session_successful = !data.stage_results.iter().any(|sr| sr.was_failed);
+
+        // Calculate invalid effort metrics from skipped/failed stages
+        let invalid_keystrokes: usize = data
+            .stage_results
+            .iter()
+            .filter(|sr| sr.was_skipped || sr.was_failed)
+            .map(|sr| sr.keystrokes)
+            .sum();
+
+        let invalid_mistakes: usize = data
+            .stage_results
+            .iter()
+            .filter(|sr| sr.was_skipped || sr.was_failed)
+            .map(|sr| sr.mistakes)
+            .sum();
+
+        // Calculate overall metrics using valid session duration
+        let (overall_wpm, overall_cpm, overall_accuracy) =
+            if valid_session_duration.as_secs() > 0 && valid_keystrokes > 0 {
+                let cpm = (valid_keystrokes as f64 / valid_session_duration.as_secs_f64()) * 60.0;
+                let wpm = cpm / 5.0;
+                let accuracy = ((valid_keystrokes.saturating_sub(valid_mistakes)) as f64
+                    / valid_keystrokes as f64)
+                    * 100.0;
+                (wpm, cpm, accuracy)
+            } else {
+                (0.0, 0.0, 0.0)
+            };
+
+        SessionResult {
+            session_start_time: data.session_start_time,
+            session_duration,
+            valid_session_duration,
+            invalid_session_duration,
+            stages_completed,
+            stages_attempted,
+            stages_skipped,
+            stage_results: data.stage_results,
+            overall_accuracy,
+            overall_wpm,
+            overall_cpm,
+            valid_keystrokes,
+            valid_mistakes,
+            invalid_keystrokes,
+            invalid_mistakes,
+            best_stage_wpm,
+            worst_stage_wpm,
+            best_stage_accuracy,
+            worst_stage_accuracy,
+            session_score,
+            session_successful,
+        }
+    }
+}

src/scoring/calculator/stage.rs

@@ -0,0 +1,117 @@
+use crate::models::{Rank, RankTier, StageResult};
+use crate::scoring::tracker::StageTracker;
+
+/// Stage level result calculation
+pub struct StageCalculator;
+
+impl StageCalculator {
+    pub fn calculate(tracker: &StageTracker, was_skipped: bool, was_failed: bool) -> StageResult {
+        let data = tracker.get_data();
+
+        if data.start_time.is_none() {
+            return StageResult::default();
+        }
+
+        // Calculate metrics from raw data
+        let cpm = if data.keystrokes.is_empty() {
+            0.1
+        } else {
+            let correct_chars = data.keystrokes.iter().filter(|k| k.is_correct).count() as f64;
+            let elapsed_secs = data.elapsed_time.as_secs_f64().max(0.1);
+            (correct_chars / elapsed_secs) * 60.0
+        };
+
+        let wpm = cpm / 5.0;
+
+        let accuracy = if data.keystrokes.is_empty() {
+            0.0
+        } else {
+            let correct_chars = data.keystrokes.iter().filter(|k| k.is_correct).count();
+            (correct_chars as f64 / data.keystrokes.len() as f64) * 100.0
+        };
+
+        let mistakes = data.keystrokes.iter().filter(|k| !k.is_correct).count();
+        let total_chars = data.keystrokes.len();
+
+        let mut all_streaks = data.streaks.clone();
+        if data.current_streak > 0 {
+            all_streaks.push(data.current_streak);
+        }
+
+        let challenge_score = crate::scoring::ScoreCalculator::calculate_score_from_metrics(
+            cpm,
+            accuracy,
+            mistakes,
+            data.elapsed_time.as_secs_f64(),
+            total_chars,
+        );
+        let rank_name = Rank::for_score(challenge_score).name().to_string();
+        let (tier_name, tier_position, tier_total, overall_position, overall_total) =
+            Self::calculate_tier_info(challenge_score);
+
+        StageResult {
+            cpm,
+            wpm,
+            accuracy,
+            keystrokes: data.keystrokes.len(),
+            mistakes,
+            consistency_streaks: all_streaks,
+            completion_time: data.elapsed_time,
+            challenge_score,
+            rank_name,
+            tier_name,
+            tier_position,
+            tier_total,
+            overall_position,
+            overall_total,
+            was_skipped,
+            was_failed,
+            challenge_path: data.challenge_path,
+        }
+    }
+
+    pub fn calculate_tier_info(score: f64) -> (String, usize, usize, usize, usize) {
+        let all_ranks = Rank::all_ranks();
+        let current_rank = Rank::for_score(score);
+
+        let same_tier_ranks: Vec<_> = all_ranks
+            .iter()
+            .filter(|rank| rank.tier() == current_rank.tier())
+            .collect();
+
+        let tier_name = match current_rank.tier() {
+            RankTier::Beginner => "Beginner",
+            RankTier::Intermediate => "Intermediate",
+            RankTier::Advanced => "Advanced",
+            RankTier::Expert => "Expert",
+            RankTier::Legendary => "Legendary",
+        }
+        .to_string();
+
+        let tier_position = same_tier_ranks
+            .iter()
+            .rev()
+            .position(|rank| rank.name() == current_rank.name())
+            .map(|pos| pos + 1)
+            .unwrap_or(1);
+
+        let tier_total = same_tier_ranks.len();
+
+        let overall_position = all_ranks
+            .iter()
+            .rev()
+            .position(|rank| rank.name() == current_rank.name())
+            .map(|pos| pos + 1)
+            .unwrap_or(1);
+
+        let overall_total = all_ranks.len();
+
+        (
+            tier_name,
+            tier_position,
+            tier_total,
+            overall_position,
+            overall_total,
+        )
+    }
+}