feat: fix semantic accuracy of all field and function names

- Fix misleading field name: rank → tier_name in StageResult
  * rank field actually contained tier names like "Beginner"
  * Now properly named tier_name for semantic accuracy
- Update all field assignments and access throughout codebase
- Fix function names: get_rank_title_display() → get_rank_display()
- Update function parameters: rank_title → rank_name
- Fix variable names: rank_title_lines → rank_lines, rank_title_height → rank_height
- Update comments and documentation to use "rank" instead of "ranking title"
- Fix closure parameter: |title| → |rank| for semantic accuracy
- Update all test files to use corrected function names

Final semantically accurate field structure:
- rank_name: String (specific rank like "Hello World")
- tier_name: String (tier category like "Beginner")
- tier_position: usize (position within the tier)
- tier_total: usize (total ranks in the tier)

All 160 tests passing, semantically consistent naming achieved.

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

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

Author: unhappychoice

src/game/ascii_rank_titles_generated.rs

@@ -700,10 +700,10 @@ pub fn get_all_rank_patterns() -> HashMap<String, Vec<String>> {
     patterns
 }
 
-pub fn get_rank_title_display(rank_title: &str) -> Vec<String> {
+pub fn get_rank_display(rank_name: &str) -> Vec<String> {
     let patterns = get_all_rank_patterns();
     patterns
-        .get(rank_title)
+        .get(rank_name)
         .cloned()
-        .unwrap_or_else(|| vec![rank_title.to_string()])
+        .unwrap_or_else(|| vec![rank_name.to_string()])
 }

src/game/screens/cancel_screen.rs

@@ -68,7 +68,7 @@ impl CancelScreen {
                         completion_time: std::time::Duration::new(0, 0),
                         challenge_score: 0.0,
                         rank_name: "Unranked".to_string(),
-                        rank: "Beginner".to_string(),
+                        tier_name: "Beginner".to_string(),
                         tier_position: 0,
                         tier_total: 0,
                         overall_position: 0,

src/game/screens/exit_summary_screen.rs

@@ -52,7 +52,7 @@ impl ExitSummaryScreen {
             completion_time: session_summary.total_session_time,
             challenge_score: session_summary.session_score,
             rank_name: ranking_title,
-            rank: tier_name,
+            tier_name,
             tier_position,
             tier_total,
             overall_position,

src/game/screens/session_summary_screen.rs

@@ -1,5 +1,5 @@
 use crate::game::ascii_digits::get_digit_patterns;
-use crate::game::ascii_rank_titles_generated::get_rank_title_display;
+use crate::game::ascii_rank_titles_generated::get_rank_display;
 use crate::scoring::{Rank, ScoringEngine, StageResult};
 use crate::{models::GitRepository, Result};
 use crossterm::{
@@ -323,11 +323,11 @@ impl SessionSummaryScreen {
         };
 
         // Display ranking title as large ASCII art at the top
-        let rank_title_lines = get_rank_title_display(&session_metrics.rank_name);
-        let rank_title_height = rank_title_lines.len() as u16;
+        let rank_lines = get_rank_display(&session_metrics.rank_name);
+        let rank_height = rank_lines.len() as u16;
 
         // Calculate total content height and center vertically
-        let total_content_height = 4 + rank_title_height + 1 + 3 + 1 + 4 + 2 + 2; // session_title_space + rank + tier + gap_after_tier + label + score + gap + summary
+        let total_content_height = 4 + rank_height + 1 + 3 + 1 + 4 + 2 + 2; // session_title_space + rank + tier + gap_after_tier + label + score + gap + summary
         let rank_start_row = if total_content_height < terminal_height {
             center_row.saturating_sub(total_content_height / 2)
         } else {
@@ -358,7 +358,7 @@ impl SessionSummaryScreen {
         execute!(stdout, Print(youre_label))?;
         execute!(stdout, ResetColor)?;
 
-        for (row_index, line) in rank_title_lines.iter().enumerate() {
+        for (row_index, line) in rank_lines.iter().enumerate() {
             // Calculate actual display width without ANSI codes for centering
             let display_width = Self::calculate_display_width(line);
             let line_col = center_col.saturating_sub(display_width / 2);
@@ -368,10 +368,10 @@ impl SessionSummaryScreen {
         }
 
         // Display tier information right after rank title (small gap after rank title)
-        let tier_info_row = rank_start_row + rank_title_height + 1;
+        let tier_info_row = rank_start_row + rank_height + 1;
         let tier_info = format!(
             "{} tier - {}/{} (overall {}/{})",
-            session_metrics.rank,
+            session_metrics.tier_name,
             session_metrics.tier_position,
             session_metrics.tier_total,
             session_metrics.overall_position,
@@ -382,7 +382,7 @@ impl SessionSummaryScreen {
         execute!(stdout, SetAttribute(Attribute::Bold))?;
 
         // Set color based on tier
-        let tier_color = match session_metrics.rank.as_str() {
+        let tier_color = match session_metrics.tier_name.as_str() {
             "Beginner" => Color::Blue,
             "Intermediate" => Color::Green,
             "Advanced" => Color::Cyan,
@@ -395,7 +395,7 @@ impl SessionSummaryScreen {
         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 + 4;
+        let score_label_row = rank_start_row + rank_height + 4;
 
         // Display "SCORE" label in normal text with color
         let score_label = "SESSION SCORE";

src/models/rank.rs

@@ -42,7 +42,7 @@ impl RankTier {
 }
 
 impl Rank {
-    /// Create a new ranking title
+    /// Create a new rank
     pub fn new(name: impl Into<String>, tier: RankTier, min_score: u32, max_score: u32) -> Self {
         Self {
             name: name.into(),
@@ -52,7 +52,7 @@ impl Rank {
         }
     }
 
-    /// Get the display name of the ranking title
+    /// Get the display name of the rank
     pub fn name(&self) -> &str {
         &self.name
     }
@@ -63,7 +63,7 @@ impl Rank {
         &self.tier
     }
 
-    /// Check if a score falls within this ranking title's range
+    /// Check if a score falls within this rank's range
     #[allow(dead_code)]
     pub fn contains_score(&self, score: f64) -> bool {
         let score = score as u32;
@@ -75,7 +75,7 @@ impl Rank {
         self.tier.color_palette()
     }
 
-    /// Get the terminal color for this ranking title
+    /// Get the terminal color for this rank
     pub fn terminal_color(&self) -> crossterm::style::Color {
         self.tier.terminal_color()
     }
@@ -154,14 +154,14 @@ impl Rank {
         ]
     }
 
-    /// Find the ranking title for a given score
+    /// Find the rank for a given score
     #[allow(dead_code)]
     pub fn for_score(score: f64) -> Rank {
         Self::all_ranks()
             .into_iter()
-            .find(|title| title.contains_score(score))
+            .find(|rank| rank.contains_score(score))
             .unwrap_or_else(|| {
-                // Fallback to highest title if score exceeds all ranges
+                // Fallback to highest rank if score exceeds all ranges
                 Rank::new("Kernel Panic", RankTier::Legendary, 40001, u32::MAX)
             })
     }

src/models/stage.rs

@@ -17,7 +17,7 @@ pub struct StageResult {
     pub completion_time: Duration,
     pub challenge_score: f64,
     pub rank_name: String,
-    pub rank: String,
+    pub tier_name: String,
     pub tier_position: usize,
     pub tier_total: usize,
     pub overall_position: usize,

src/scoring/engine.rs

@@ -484,7 +484,7 @@ impl ScoringEngine {
             completion_time: self.elapsed(),
             challenge_score,
             rank_name,
-            rank: tier_name,
+            tier_name,
             tier_position,
             tier_total,
             overall_position,
@@ -532,7 +532,7 @@ impl ScoringEngine {
             completion_time: temp_engine.elapsed(),
             challenge_score,
             rank_name,
-            rank: tier_name,
+            tier_name,
             tier_position,
             tier_total,
             overall_position,

tests/ascii_art_coverage_tests.rs

@@ -1,12 +1,12 @@
-use gittype::game::ascii_rank_titles_generated::get_rank_title_display;
+use gittype::game::ascii_rank_titles_generated::get_rank_display;
 use gittype::models::{RankTier, Rank};
 
 #[test]
 fn test_all_rank_titles_have_ascii_art() {
     let titles = Rank::all_ranks();
 
     for title in &titles {
-        let ascii_art = get_rank_title_display(title.name());
+        let ascii_art = get_rank_display(title.name());
 
         // Verify ASCII art exists (not empty)
         assert!(
@@ -78,7 +78,7 @@ fn test_ascii_art_quality() {
 
     for title in titles.iter().take(10) {
         // Test first 10 titles for performance
-        let ascii_art = get_rank_title_display(title.name());
+        let ascii_art = get_rank_display(title.name());
 
         // Verify minimum quality standards
         assert!(

tests/missing_ascii_art_test.rs

@@ -1,4 +1,4 @@
-use gittype::game::ascii_rank_titles_generated::get_rank_title_display;
+use gittype::game::ascii_rank_titles_generated::get_rank_display;
 use gittype::models::Rank;
 
 #[test]
@@ -9,7 +9,7 @@ fn test_identify_missing_ascii_art() {
     let mut has_art = Vec::new();
 
     for title in &titles {
-        let ascii_art = get_rank_title_display(title.name());
+        let ascii_art = get_rank_display(title.name());
 
         if ascii_art.len() == 1 && ascii_art[0] == title.name() {
             // This is fallback behavior - no actual ASCII art