feat: complete method and variable name unification

- Update StageResult field: ranking_title → rank_name
- Update all field access to use rank_name consistently
- Fix scoring engine variable names: ranking_title → rank_name
- Update test files to use new field names
- Fix function parameter names in animation and screen modules

Method/Field/Variable consistency achieved:
- rank_name: String (specific rank title like "Hello World")
- rank: String (tier name like "Beginner")
- tier_position/tier_total: position within tier
- overall_position/overall_total: position across all tiers

All 160 tests passing, clean compilation.

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

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

Author: unhappychoice

src/game/rank_messages.rs

@@ -965,17 +965,17 @@ fn get_rank_messages_3() -> &'static HashMap<&'static str, Vec<(&'static str, Co
 }
 
 /// Get hacking messages for a specific rank
-pub fn get_hacking_messages_for_rank(ranking_title: &str) -> Vec<String> {
+pub fn get_hacking_messages_for_rank(rank_name: &str) -> Vec<String> {
     // Check all three message maps
-    if let Some(messages) = get_rank_messages().get(ranking_title) {
+    if let Some(messages) = get_rank_messages().get(rank_name) {
         return messages.iter().map(|(text, _)| text.to_string()).collect();
     }
 
-    if let Some(messages) = get_rank_messages_2().get(ranking_title) {
+    if let Some(messages) = get_rank_messages_2().get(rank_name) {
         return messages.iter().map(|(text, _)| text.to_string()).collect();
     }
 
-    if let Some(messages) = get_rank_messages_3().get(ranking_title) {
+    if let Some(messages) = get_rank_messages_3().get(rank_name) {
         return messages.iter().map(|(text, _)| text.to_string()).collect();
     }
 
@@ -989,9 +989,9 @@ pub fn get_hacking_messages_for_rank(ranking_title: &str) -> Vec<String> {
 }
 
 /// Get colored messages for a specific rank
-pub fn get_colored_messages_for_rank(ranking_title: &str) -> Vec<ColoredMessage> {
+pub fn get_colored_messages_for_rank(rank_name: &str) -> Vec<ColoredMessage> {
     // Check all three message maps
-    if let Some(messages) = get_rank_messages().get(ranking_title) {
+    if let Some(messages) = get_rank_messages().get(rank_name) {
         return messages
             .iter()
             .map(|(text, color)| ColoredMessage {
@@ -1001,7 +1001,7 @@ pub fn get_colored_messages_for_rank(ranking_title: &str) -> Vec<ColoredMessage>
             .collect();
     }
 
-    if let Some(messages) = get_rank_messages_2().get(ranking_title) {
+    if let Some(messages) = get_rank_messages_2().get(rank_name) {
         return messages
             .iter()
             .map(|(text, color)| ColoredMessage {
@@ -1011,7 +1011,7 @@ pub fn get_colored_messages_for_rank(ranking_title: &str) -> Vec<ColoredMessage>
             .collect();
     }
 
-    if let Some(messages) = get_rank_messages_3().get(ranking_title) {
+    if let Some(messages) = get_rank_messages_3().get(rank_name) {
         return messages
             .iter()
             .map(|(text, color)| ColoredMessage {

src/game/screens/animation_screen.rs

@@ -42,7 +42,7 @@ impl AnimationScreen {
     fn render_typing_animation_ratatui(
         frame: &mut Frame,
         animation: &TypingAnimation,
-        _ranking_title: &str,
+        _rank_name: &str,
     ) {
         let area = frame.size();
 
@@ -149,7 +149,7 @@ impl AnimationScreen {
 
     // Helper function to get tier from ranking title name
     fn get_tier_from_title(title_name: &str) -> crate::models::RankTier {
-        Rank::all_titles()
+        Rank::all_ranks()
             .iter()
             .find(|title| title.name() == title_name)
             .map(|title| title.tier().clone())
@@ -186,17 +186,17 @@ impl AnimationScreen {
         terminal.clear()?;
 
         // Create typing animation for session complete
-        let tier = Self::get_tier_from_title(&session_metrics.ranking_title);
+        let tier = Self::get_tier_from_title(&session_metrics.rank_name);
         let mut typing_animation =
             TypingAnimation::new(tier, terminal.size()?.width, terminal.size()?.height);
-        typing_animation.set_rank_messages(&session_metrics.ranking_title);
+        typing_animation.set_rank_messages(&session_metrics.rank_name);
 
         // Show typing reveal animation with ratatui
         while !typing_animation.is_complete() {
             let updated = typing_animation.update();
 
             if updated {
-                let ranking_title = session_metrics.ranking_title.clone();
+                let ranking_title = session_metrics.rank_name.clone();
                 terminal.draw(|frame| {
                     Self::render_typing_animation_ratatui(frame, &typing_animation, &ranking_title);
                 })?;

src/game/screens/cancel_screen.rs

@@ -67,7 +67,7 @@ impl CancelScreen {
                         consistency_streaks: vec![],
                         completion_time: std::time::Duration::new(0, 0),
                         challenge_score: 0.0,
-                        ranking_title: "Unranked".to_string(),
+                        rank_name: "Unranked".to_string(),
                         rank: "Beginner".to_string(),
                         tier_position: 0,
                         tier_total: 0,

src/game/screens/exit_summary_screen.rs

@@ -37,7 +37,7 @@ impl ExitSummaryScreen {
 
         // Create a StageResult from SessionSummary data
         let ranking_title =
-            ScoringEngine::get_ranking_title_for_score(session_summary.session_score)
+            ScoringEngine::get_rank_for_score(session_summary.session_score)
                 .name()
                 .to_string();
         let (tier_name, tier_position, tier_total, overall_position, overall_total) =
@@ -51,7 +51,7 @@ impl ExitSummaryScreen {
             consistency_streaks: vec![], // Not available in session summary
             completion_time: session_summary.total_session_time,
             challenge_score: session_summary.session_score,
-            ranking_title,
+            rank_name: ranking_title,
             rank: tier_name,
             tier_position,
             tier_total,

src/game/screens/session_summary_screen.rs

@@ -323,7 +323,7 @@ impl SessionSummaryScreen {
         };
 
         // Display ranking title as large ASCII art at the top
-        let rank_title_lines = get_rank_title_display(&session_metrics.ranking_title);
+        let rank_title_lines = get_rank_title_display(&session_metrics.rank_name);
         let rank_title_height = rank_title_lines.len() as u16;
 
         // Calculate total content height and center vertically

src/game/screens/sharing_screen.rs

@@ -55,7 +55,7 @@ impl SharingScreen {
         let preview_text = if let Some(repo) = repo_info {
             format!(
                 "\"{}\" with {:.0}pts on [{}/{}] - CPM: {:.0}, Mistakes: {}",
-                metrics.ranking_title,
+                metrics.rank_name,
                 metrics.challenge_score,
                 repo.user_name,
                 repo.repository_name,
@@ -65,7 +65,7 @@ impl SharingScreen {
         } else {
             format!(
                 "\"{}\" with {:.0}pts - CPM: {:.0}, Mistakes: {}",
-                metrics.ranking_title, metrics.challenge_score, metrics.cpm, metrics.mistakes
+                metrics.rank_name, metrics.challenge_score, metrics.cpm, metrics.mistakes
             )
         };
         let preview_col = center_col.saturating_sub(preview_text.len() as u16 / 2);

src/game/typing_animation.rs

@@ -39,9 +39,9 @@ impl TypingAnimation {
         }
     }
 
-    pub fn set_rank_messages(&mut self, ranking_title: &str) {
+    pub fn set_rank_messages(&mut self, rank_name: &str) {
         use crate::game::rank_messages::get_colored_messages_for_rank;
-        let colored_messages = get_colored_messages_for_rank(ranking_title);
+        let colored_messages = get_colored_messages_for_rank(rank_name);
         self.hacking_lines = colored_messages
             .into_iter()
             .map(|msg| HackingLine {

src/models/rank.rs

@@ -80,8 +80,8 @@ impl Rank {
         self.tier.terminal_color()
     }
 
-    /// Get all ranking titles in order from lowest to highest score
-    pub fn all_titles() -> Vec<Rank> {
+    /// Get all ranks in order from lowest to highest score
+    pub fn all_ranks() -> Vec<Rank> {
         vec![
             // Beginner Level (clean boundaries, ~even progression)
             Rank::new("Hello World", RankTier::Beginner, 0, 800),
@@ -157,7 +157,7 @@ impl Rank {
     /// Find the ranking title for a given score
     #[allow(dead_code)]
     pub fn for_score(score: f64) -> Rank {
-        Self::all_titles()
+        Self::all_ranks()
             .into_iter()
             .find(|title| title.contains_score(score))
             .unwrap_or_else(|| {

src/models/stage.rs

@@ -16,7 +16,7 @@ pub struct StageResult {
     pub consistency_streaks: Vec<usize>,
     pub completion_time: Duration,
     pub challenge_score: f64,
-    pub ranking_title: String,
+    pub rank_name: String,
     pub rank: String,
     pub tier_position: usize,
     pub tier_total: usize,

src/scoring/engine.rs

@@ -169,26 +169,26 @@ impl ScoringEngine {
         all_streaks
     }
 
-    /// Get ranking title for current engine state
-    pub fn get_ranking_title(&self) -> Rank {
+    /// Get rank for current engine state
+    pub fn get_rank(&self) -> Rank {
         let score = self.calculate_challenge_score();
-        Self::get_ranking_title_for_score(score)
+        Self::get_rank_for_score(score)
     }
 
-    /// Legacy method that returns title name as string for backward compatibility
-    pub fn get_ranking_title_string(&self) -> String {
-        self.get_ranking_title().name().to_string()
+    /// Get rank name as string
+    pub fn get_rank_name(&self) -> String {
+        self.get_rank().name().to_string()
     }
 
-    /// Get ranking title for a specific score (pure function for testing)
-    pub fn get_ranking_title_for_score(score: f64) -> Rank {
+    /// Get rank for a specific score (pure function for testing)
+    pub fn get_rank_for_score(score: f64) -> Rank {
         Rank::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 = Rank::all_titles();
-        let current_title = Self::get_ranking_title_for_score(score);
+        let all_titles = Rank::all_ranks();
+        let current_title = Self::get_rank_for_score(score);
 
         // Find titles in the same tier
         let same_tier_titles: Vec<_> = all_titles
@@ -234,8 +234,8 @@ impl ScoringEngine {
         )
     }
 
-    /// 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 {
+    /// Get rank name as string for a specific score
+    pub fn get_rank_name_for_score(score: f64) -> String {
         match score as usize {
             // Beginner Level (clean boundaries, ~even progression)
             0..=800 => "Hello World".to_string(),
@@ -312,9 +312,9 @@ impl ScoringEngine {
         }
     }
 
-    /// Get legacy ranking title name for a specific score (deprecated - use get_ranking_title_for_score instead)
-    pub fn get_ranking_title_legacy_for_score(score: f64) -> String {
-        Self::get_ranking_title_for_score(score).name().to_string()
+    /// Get legacy rank name for a specific score (deprecated - use get_rank_for_score instead)
+    pub fn get_rank_name_legacy_for_score(score: f64) -> String {
+        Self::get_rank_for_score(score).name().to_string()
     }
 
     /// Calculate base score from current metrics
@@ -469,7 +469,7 @@ impl ScoringEngine {
         }
 
         let challenge_score = self.calculate_challenge_score();
-        let ranking_title = Self::get_ranking_title_for_score(challenge_score)
+        let rank_name = Self::get_rank_for_score(challenge_score)
             .name()
             .to_string();
         let (tier_name, tier_position, tier_total, overall_position, overall_total) =
@@ -483,7 +483,7 @@ impl ScoringEngine {
             consistency_streaks: self.all_streaks(),
             completion_time: self.elapsed(),
             challenge_score,
-            ranking_title,
+            rank_name,
             rank: tier_name,
             tier_position,
             tier_total,
@@ -517,7 +517,7 @@ impl ScoringEngine {
         }
 
         let challenge_score = temp_engine.calculate_challenge_score();
-        let ranking_title = Self::get_ranking_title_for_score(challenge_score)
+        let rank_name = Self::get_rank_for_score(challenge_score)
             .name()
             .to_string();
         let (tier_name, tier_position, tier_total, overall_position, overall_total) =
@@ -531,7 +531,7 @@ impl ScoringEngine {
             consistency_streaks: vec![], // Real-time doesn't track actual streaks
             completion_time: temp_engine.elapsed(),
             challenge_score,
-            ranking_title,
+            rank_name,
             rank: tier_name,
             tier_position,
             tier_total,