feat: add tier and overall ranking display to result screen

- Add tier position and overall ranking information to TypingMetrics
- Display tier rank (e.g., "Expert tier - rank 3/12") with tier-based colors
- Show overall ranking across all titles (e.g., "overall 25/75")
- Implement calculate_tier_info method in ScoringEngine
- Improve result screen layout with proper spacing
- Fix ranking order to show highest score requirements as rank 1

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

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

Author: unhappychoice

src/game/screens/exit_summary_screen.rs

@@ -40,6 +40,8 @@ impl ExitSummaryScreen {
             ScoringEngine::get_ranking_title_for_score(session_summary.session_score)
                 .name()
                 .to_string();
+        let (tier_name, tier_position, tier_total, overall_position, overall_total) = 
+            ScoringEngine::calculate_tier_info(session_summary.session_score);
 
         TypingMetrics {
             cpm: session_summary.overall_cpm,
@@ -50,6 +52,11 @@ impl ExitSummaryScreen {
             completion_time: session_summary.total_session_time,
             challenge_score: session_summary.session_score,
             ranking_title,
+            ranking_tier: tier_name,
+            tier_position,
+            tier_total,
+            overall_position,
+            overall_total,
             was_skipped: false,
             was_failed: false,
         }

src/game/screens/result_screen.rs

@@ -317,7 +317,7 @@ impl ResultScreen {
         let rank_title_height = rank_title_lines.len() as u16;
 
         // Calculate total content height and center vertically
-        let total_content_height = rank_title_height + 1 + 1 + 4 + 2 + 2; // rank + gap + label + score + gap + summary
+        let total_content_height = rank_title_height + 1 + 1 + 2 + 4 + 2 + 2; // rank + gap + tier + extra gap + label + score + gap + summary
         let rank_start_row = if total_content_height < terminal_height {
             center_row.saturating_sub(total_content_height / 2)
         } else {
@@ -332,7 +332,7 @@ impl ResultScreen {
             let title_col = center_col.saturating_sub(line.len() as u16 / 2);
             execute!(
                 stdout,
-                MoveTo(title_col, rank_start_row.saturating_sub(6) + i as u16)
+                MoveTo(title_col, rank_start_row.saturating_sub(5) + i as u16)
             )?;
             execute!(
                 stdout,
@@ -343,10 +343,10 @@ impl ResultScreen {
             execute!(stdout, ResetColor)?;
         }
 
-        // Display "you're:" label before rank title (no gap)
+        // Display "you're:" label before rank title (1 line gap from rank title)
         let youre_label = "YOU'RE:";
         let youre_col = center_col.saturating_sub(youre_label.len() as u16 / 2);
-        execute!(stdout, MoveTo(youre_col, rank_start_row.saturating_sub(1)))?;
+        execute!(stdout, MoveTo(youre_col, rank_start_row.saturating_sub(2)))?;
         execute!(
             stdout,
             SetAttribute(Attribute::Bold),
@@ -364,8 +364,34 @@ impl ResultScreen {
             execute!(stdout, ResetColor)?;
         }
 
-        // Calculate score position based on rank title height (add gap after rank title)
-        let score_label_row = rank_start_row + rank_title_height + 1;
+        // Display tier information right after rank title (small gap after rank title)
+        let tier_info_row = rank_start_row + rank_title_height;
+        let tier_info = format!("{} tier - rank {}/{} (overall {}/{})", 
+            session_metrics.ranking_tier, 
+            session_metrics.tier_position, 
+            session_metrics.tier_total,
+            session_metrics.overall_position,
+            session_metrics.overall_total
+        );
+        let tier_info_col = center_col.saturating_sub(tier_info.len() as u16 / 2);
+        execute!(stdout, MoveTo(tier_info_col, tier_info_row))?;
+        execute!(stdout, SetAttribute(Attribute::Bold))?;
+        
+        // Set color based on tier
+        let tier_color = match session_metrics.ranking_tier.as_str() {
+            "Beginner" => Color::Blue,
+            "Intermediate" => Color::Green,
+            "Advanced" => Color::Cyan,
+            "Expert" => Color::Yellow,
+            "Legendary" => Color::Red,
+            _ => Color::White,
+        };
+        execute!(stdout, SetForegroundColor(tier_color))?;
+        execute!(stdout, Print(&tier_info))?;
+        execute!(stdout, ResetColor)?;
+
+        // Calculate score position based on rank title height and tier info (add extra gap after tier info)
+        let score_label_row = rank_start_row + rank_title_height + 3;
 
         // Display "SCORE" label in normal text with color
         let score_label = "SESSION SCORE";

src/scoring/engine.rs

@@ -185,6 +185,48 @@ impl ScoringEngine {
         RankingTitle::for_score(score)
     }
 
+    /// Calculate tier position and total for a given score
+    pub fn calculate_tier_info(score: f64) -> (String, usize, usize, usize, usize) {
+        let all_titles = RankingTitle::all_titles();
+        let current_title = Self::get_ranking_title_for_score(score);
+        
+        // Find titles in the same tier
+        let same_tier_titles: Vec<_> = all_titles
+            .iter()
+            .filter(|title| title.tier() == current_title.tier())
+            .collect();
+        
+        let tier_name = match current_title.tier() {
+            super::RankingTier::Beginner => "Beginner",
+            super::RankingTier::Intermediate => "Intermediate",
+            super::RankingTier::Advanced => "Advanced",
+            super::RankingTier::Expert => "Expert",
+            super::RankingTier::Legendary => "Legendary",
+        }.to_string();
+        
+        // Find position within tier (1-based, highest score = rank 1)
+        let tier_position = same_tier_titles
+            .iter()
+            .rev() // Reverse to get highest scores first
+            .position(|title| title.name() == current_title.name())
+            .map(|pos| pos + 1)
+            .unwrap_or(1);
+        
+        let tier_total = same_tier_titles.len();
+        
+        // Find position in all titles (1-based, highest score = rank 1)
+        let overall_position = all_titles
+            .iter()
+            .rev() // Reverse to get highest scores first
+            .position(|title| title.name() == current_title.name())
+            .map(|pos| pos + 1)
+            .unwrap_or(1);
+        
+        let overall_total = all_titles.len();
+        
+        (tier_name, tier_position, tier_total, overall_position, overall_total)
+    }
+
     /// Legacy method that returns title name as string for a score for backward compatibility
     pub fn get_ranking_title_string_for_score(score: f64) -> String {
         match score as usize {
@@ -423,6 +465,7 @@ impl ScoringEngine {
         let ranking_title = Self::get_ranking_title_for_score(challenge_score)
             .name()
             .to_string();
+        let (tier_name, tier_position, tier_total, overall_position, overall_total) = Self::calculate_tier_info(challenge_score);
 
         Ok(TypingMetrics {
             cpm: self.cpm(),
@@ -433,6 +476,11 @@ impl ScoringEngine {
             completion_time: self.elapsed(),
             challenge_score,
             ranking_title,
+            ranking_tier: tier_name,
+            tier_position,
+            tier_total,
+            overall_position,
+            overall_total,
             was_skipped,
             was_failed,
         })
@@ -464,6 +512,7 @@ impl ScoringEngine {
         let ranking_title = Self::get_ranking_title_for_score(challenge_score)
             .name()
             .to_string();
+        let (tier_name, tier_position, tier_total, overall_position, overall_total) = Self::calculate_tier_info(challenge_score);
 
         TypingMetrics {
             cpm: temp_engine.cpm(),
@@ -474,6 +523,11 @@ impl ScoringEngine {
             completion_time: temp_engine.elapsed(),
             challenge_score,
             ranking_title,
+            ranking_tier: tier_name,
+            tier_position,
+            tier_total,
+            overall_position,
+            overall_total,
             was_skipped: false, // Real-time metrics are not skipped
             was_failed: false,  // Real-time metrics are not failed
         }

src/scoring/metrics.rs

@@ -10,6 +10,11 @@ pub struct TypingMetrics {
     pub completion_time: Duration,
     pub challenge_score: f64,
     pub ranking_title: String,
+    pub ranking_tier: String,
+    pub tier_position: usize,
+    pub tier_total: usize,
+    pub overall_position: usize,
+    pub overall_total: usize,
     pub was_skipped: bool,
     pub was_failed: bool,
 }