feat: add typing animation with colored messages and skip functionality

- Add typing animation screen with typewriter effect for session results
- Implement line-by-line colored messages for all 51 ranking titles
- Add humorous IT industry messages for Beginner, Advanced, Expert tiers
- Add world-breaking themed messages for Legendary bug-related ranks
- Add [S] to skip functionality with right-corner display
- Refactor message system with per-line color information
- Clean up unused animation code and rename gacha_animation to typing_animation
- Remove obsolete animation.rs file entirely
- Integrate animation into session summary workflow

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

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

Author: unhappychoice

generate_all_ascii_titles

@@ -8,6 +8,8 @@ pub mod stage_manager;
 pub mod stage_builder;
 pub mod ascii_digits;
 pub mod ascii_rank_titles_generated;
+pub mod typing_animation;
+pub mod rank_messages;
 
 pub use screens::TypingScreen;
 pub use challenge::Challenge;

src/game/mod.rs

@@ -0,0 +1,214 @@
+use crate::Result;
+use crate::scoring::{ScoringEngine, RankingTitle};
+use crate::game::typing_animation::{TypingAnimation, AnimationPhase};
+use crossterm::event::{self, Event, KeyCode};
+use ratatui::{
+    backend::CrosstermBackend,
+    layout::{Alignment, Constraint, Direction, Layout},
+    style::Style,
+    text::{Line, Span, Text},
+    widgets::Paragraph,
+    Terminal, Frame,
+};
+use std::io;
+
+pub struct AnimationScreen;
+
+impl AnimationScreen {
+    // Helper function to convert crossterm::Color to ratatui::Color
+    fn convert_crossterm_color(color: crossterm::style::Color) -> ratatui::style::Color {
+        match color {
+            crossterm::style::Color::Black => ratatui::style::Color::Black,
+            crossterm::style::Color::DarkGrey => ratatui::style::Color::DarkGray,
+            crossterm::style::Color::Red => ratatui::style::Color::Red,
+            crossterm::style::Color::DarkRed => ratatui::style::Color::DarkGray,
+            crossterm::style::Color::Green => ratatui::style::Color::Green,
+            crossterm::style::Color::DarkGreen => ratatui::style::Color::DarkGray,
+            crossterm::style::Color::Yellow => ratatui::style::Color::Yellow,
+            crossterm::style::Color::DarkYellow => ratatui::style::Color::DarkGray,
+            crossterm::style::Color::Blue => ratatui::style::Color::Blue,
+            crossterm::style::Color::DarkBlue => ratatui::style::Color::DarkGray,
+            crossterm::style::Color::Magenta => ratatui::style::Color::Magenta,
+            crossterm::style::Color::DarkMagenta => ratatui::style::Color::DarkGray,
+            crossterm::style::Color::Cyan => ratatui::style::Color::Cyan,
+            crossterm::style::Color::DarkCyan => ratatui::style::Color::DarkGray,
+            crossterm::style::Color::White => ratatui::style::Color::White,
+            crossterm::style::Color::Grey => ratatui::style::Color::Gray,
+            _ => ratatui::style::Color::White, // Default fallback
+        }
+    }
+
+    // Helper function to render typing animation with ratatui
+    fn render_typing_animation_ratatui(frame: &mut Frame, animation: &TypingAnimation, _ranking_title: &str) {
+        let area = frame.size();
+        
+        // Create vertical layout for centering
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([
+                Constraint::Percentage(40), // Top padding
+                Constraint::Min(4),         // Animation area
+                Constraint::Percentage(40), // Bottom padding
+            ])
+            .split(area);
+        
+        match animation.get_current_phase() {
+            AnimationPhase::ConcentrationLines => {
+                let mut lines = Vec::new();
+                
+                for (i, line) in animation.get_hacking_lines().iter().enumerate() {
+                    let text = &line.text[..line.typed_length];
+                    let line_color = Self::convert_crossterm_color(line.color);
+                    
+                    if i == animation.get_current_line() && line.typed_length < line.text.len() && !line.completed {
+                        // Show cursor on current line
+                        lines.push(Line::from(vec![
+                            Span::styled(text, Style::default().fg(line_color)),
+                            Span::styled("█", Style::default().fg(ratatui::style::Color::White)),
+                        ]));
+                    } else if !text.is_empty() {
+                        // Regular completed or typing line
+                        lines.push(Line::from(
+                            Span::styled(text, Style::default().fg(line_color))
+                        ));
+                    } else {
+                        // Empty placeholder line
+                        lines.push(Line::from(""));
+                    }
+                }
+                
+                let paragraph = Paragraph::new(Text::from(lines))
+                    .alignment(Alignment::Center);
+                    
+                frame.render_widget(paragraph, chunks[1]);
+                
+                // Render skip hint in bottom right
+                Self::render_skip_hint(frame, area);
+            }
+            AnimationPhase::Pause => {
+                // Show all completed lines plus dots
+                let mut lines = Vec::new();
+                
+                for line in animation.get_hacking_lines().iter() {
+                    let line_color = Self::convert_crossterm_color(line.color);
+                    lines.push(Line::from(
+                        Span::styled(&line.text, Style::default().fg(line_color))
+                    ));
+                }
+                
+                // Add dots line
+                let dots = ".".repeat(animation.get_pause_dots());
+                lines.push(Line::from(
+                    Span::styled(dots, Style::default().fg(ratatui::style::Color::Gray))
+                ));
+                
+                let paragraph = Paragraph::new(Text::from(lines))
+                    .alignment(Alignment::Center);
+                    
+                frame.render_widget(paragraph, chunks[1]);
+                
+                // Render skip hint in bottom right
+                Self::render_skip_hint(frame, area);
+            }
+            AnimationPhase::Complete => {
+                // Animation is complete, ready to transition to result
+            }
+        }
+    }
+
+    // Helper function to render skip hint in bottom right corner
+    fn render_skip_hint(frame: &mut Frame, area: ratatui::layout::Rect) {
+        let skip_text = "[S] Skip";
+        let skip_width = skip_text.len() as u16;
+        let skip_height = 1;
+        
+        // Position in bottom right corner with small margin
+        let skip_x = area.width.saturating_sub(skip_width + 1);
+        let skip_y = area.height.saturating_sub(skip_height + 1);
+        
+        let skip_area = ratatui::layout::Rect {
+            x: skip_x,
+            y: skip_y,
+            width: skip_width,
+            height: skip_height,
+        };
+        
+        let skip_paragraph = Paragraph::new(skip_text)
+            .style(Style::default().fg(ratatui::style::Color::Gray));
+            
+        frame.render_widget(skip_paragraph, skip_area);
+    }
+
+    // Helper function to get tier from ranking title name
+    fn get_tier_from_title(title_name: &str) -> crate::scoring::RankingTier {
+        RankingTitle::all_titles()
+            .iter()
+            .find(|title| title.name() == title_name)
+            .map(|title| title.tier().clone())
+            .unwrap_or(crate::scoring::RankingTier::Beginner)
+    }
+
+    pub fn show_session_animation(
+        _total_stages: usize,
+        _completed_stages: usize, 
+        stage_engines: &[(String, ScoringEngine)],
+    ) -> Result<()> {
+        // Calculate aggregated session metrics by combining ScoringEngines with + operator
+        if stage_engines.is_empty() {
+            return Ok(());
+        }
+
+        let combined_engine = stage_engines.iter()
+            .map(|(_, engine)| engine.clone())
+            .reduce(|acc, engine| acc + engine)
+            .unwrap(); // Safe because we checked is_empty() above
+
+        let session_metrics = match combined_engine.calculate_metrics() {
+            Ok(metrics) => metrics,
+            Err(_) => {
+                // Fallback if calculation fails
+                return Ok(());
+            }
+        };
+
+        // Set up ratatui terminal
+        let backend = CrosstermBackend::new(io::stdout());
+        let mut terminal = Terminal::new(backend)?;
+        terminal.clear()?;
+
+        // Create typing animation for session complete
+        let tier = Self::get_tier_from_title(&session_metrics.ranking_title);
+        let mut typing_animation = TypingAnimation::new(tier, terminal.size()?.width, terminal.size()?.height);
+        typing_animation.set_rank_messages(&session_metrics.ranking_title);
+        
+        // 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();
+                terminal.draw(|frame| {
+                    Self::render_typing_animation_ratatui(frame, &typing_animation, &ranking_title);
+                })?;
+            }
+            
+            // Check for S key to skip animation
+            if event::poll(std::time::Duration::from_millis(50))? {
+                if let Event::Key(key_event) = event::read()? {
+                    match key_event.code {
+                        KeyCode::Char('s') | KeyCode::Char('S') => {
+                            break;
+                        }
+                        _ => {
+                            // Ignore other keys to prevent accidental skipping
+                        }
+                    }
+                }
+            }
+            
+            std::thread::sleep(std::time::Duration::from_millis(16)); // ~60fps
+        }
+        
+        Ok(())
+    }
+}

src/game/rank_messages.rs

@@ -3,9 +3,11 @@ pub mod result_screen;
 pub mod countdown_screen;
 pub mod typing_screen;
 pub mod loading_screen;
+pub mod animation_screen;
 
 pub use title_screen::{TitleScreen, TitleAction};
 pub use result_screen::{ResultScreen, ResultAction};
 pub use countdown_screen::CountdownScreen;
 pub use typing_screen::TypingScreen;
-pub use loading_screen::LoadingScreen;
+pub use loading_screen::LoadingScreen;
+pub use animation_screen::AnimationScreen;

src/game/screens/animation_screen.rs

@@ -71,45 +71,16 @@ impl ResultScreen {
         let center_row = terminal_height / 2;
         let center_col = terminal_width / 2;
 
-        // Display ranking title as large ASCII art at the top
-        let rank_title_lines = get_rank_title_display(&metrics.ranking_title);
-        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 + 1 + 1 + 4; // rank + gap + label + score + gap + metrics + options
-        let rank_start_row = if total_content_height < terminal_height {
-            center_row.saturating_sub(total_content_height / 2)
-        } else {
-            3
-        };
-
-        // Display stage title at the top
+        // Display stage title at the center
         let stage_title = format!("🎯 STAGE {} COMPLETE 🎯", current_stage);
         let title_col = center_col.saturating_sub(stage_title.len() as u16 / 2);
-        execute!(stdout, MoveTo(title_col, rank_start_row.saturating_sub(4)))?;
+        execute!(stdout, MoveTo(title_col, center_row.saturating_sub(6)))?;
         execute!(stdout, SetAttribute(Attribute::Bold), SetForegroundColor(Color::Yellow))?;
         execute!(stdout, Print(&stage_title))?;
         execute!(stdout, ResetColor)?;
 
-        // Display "you're:" label before rank title (no gap)
-        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, SetAttribute(Attribute::Bold), SetForegroundColor(Color::Cyan))?;
-        execute!(stdout, Print(youre_label))?;
-        execute!(stdout, ResetColor)?;
-        
-        for (row_index, line) in rank_title_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);
-            execute!(stdout, MoveTo(line_col, rank_start_row + row_index as u16))?;
-            execute!(stdout, Print(line))?;
-            execute!(stdout, ResetColor)?;
-        }
-
-        // Calculate dynamic positioning based on rank title height
-        let score_label_row = rank_start_row + rank_title_height + 1;
+        // Position score label below title
+        let score_label_row = center_row.saturating_sub(3);
 
         // Display "SCORE" label
         let score_label = "SCORE";
@@ -196,6 +167,20 @@ impl ResultScreen {
     }
 
     pub fn show_session_summary(
+        total_stages: usize,
+        completed_stages: usize, 
+        stage_engines: &[(String, ScoringEngine)],
+    ) -> Result<()> {
+        use crate::game::screens::AnimationScreen;
+        
+        // First show the animation
+        AnimationScreen::show_session_animation(total_stages, completed_stages, stage_engines)?;
+        
+        // Then show the original result screen
+        Self::show_session_summary_original(total_stages, completed_stages, stage_engines)
+    }
+    
+    pub fn show_session_summary_original(
         _total_stages: usize,
         _completed_stages: usize, 
         stage_engines: &[(String, ScoringEngine)],
@@ -357,11 +342,17 @@ impl ResultScreen {
     }
 
     pub fn show_session_summary_with_input(
-        _total_stages: usize,
-        _completed_stages: usize, 
+        total_stages: usize,
+        completed_stages: usize, 
         stage_engines: &[(String, ScoringEngine)],
     ) -> Result<ResultAction> {
-        Self::show_session_summary(_total_stages, _completed_stages, stage_engines)?;
+        use crate::game::screens::AnimationScreen;
+        
+        // First show the animation
+        AnimationScreen::show_session_animation(total_stages, completed_stages, stage_engines)?;
+        
+        // Then show the original result screen
+        Self::show_session_summary_original(total_stages, completed_stages, stage_engines)?;
 
         // Wait for user input and return action
         loop {