refactor: delegate input processing responsibility to typing_core

- Add high-level input processing methods to TypingCore:
  * process_character_input() - handles character input with result
  * process_enter_input() - handles Enter key with line-end logic
  * process_tab_input() - handles Tab key input
- Add InputResult enum to communicate typing results clearly
- Replace low-level typing_screen input handling with typing_core delegation
- Simplify typing_screen key handlers to use new high-level API
- Remove process_keystroke() in favor of handle_input_result()
- Centralize all typing logic decisions in typing_core layer

Author: unhappychoice

src/game/screens/typing_screen.rs

@@ -1,7 +1,7 @@
 use super::{
     super::{
         stage_renderer::StageRenderer,
-        typing_core::{ProcessingOptions, TypingCore},
+        typing_core::{InputResult, ProcessingOptions, TypingCore},
     },
     CountdownScreen,
 };
@@ -218,58 +218,39 @@ impl TypingScreen {
     }
 
     fn handle_tab_key(&mut self) -> Result<SessionState> {
-        if !self.typing_core.can_accept_input() {
-            return Ok(SessionState::Continue);
-        }
-
-        let is_correct = self.typing_core.check_character_match('\t');
-        self.process_keystroke('\t', is_correct)
+        let result = self.typing_core.process_tab_input();
+        self.scoring_engine.record_keystroke('\t', self.typing_core.current_position_to_type());
+        self.handle_input_result(result)
     }
 
     fn handle_enter_key(&mut self) -> Result<SessionState> {
-        if !self.typing_core.can_accept_input() {
-            return Ok(SessionState::Continue);
-        }
-
-        let is_correct = self.typing_core.is_at_line_end_for_enter();
+        let result = self.typing_core.process_enter_input();
         self.scoring_engine.record_keystroke('\n', self.typing_core.current_position_to_type());
-
-        if is_correct {
-            self.current_mistake_position = None;
-            self.typing_core.handle_newline_advance();
-            if self.typing_core.is_completed() {
-                return Ok(SessionState::Complete);
-            }
-        } else {
-            self.record_mistake();
-        }
-
-        Ok(SessionState::Continue)
+        self.handle_input_result(result)
     }
 
     fn handle_character_input(&mut self, ch: char) -> Result<SessionState> {
-        if !self.typing_core.can_accept_input() {
-            return Ok(SessionState::Continue);
-        }
-
-        let is_correct = self.typing_core.check_character_match(ch);
-        self.process_keystroke(ch, is_correct)
-    }
-
-    fn process_keystroke(&mut self, ch: char, is_correct: bool) -> Result<SessionState> {
+        let result = self.typing_core.process_character_input(ch);
         self.scoring_engine.record_keystroke(ch, self.typing_core.current_position_to_type());
+        self.handle_input_result(result)
+    }
 
-        if is_correct {
-            self.current_mistake_position = None;
-            self.typing_core.advance_to_next_character();
-            if self.typing_core.is_completed() {
-                return Ok(SessionState::Complete);
+    fn handle_input_result(&mut self, result: InputResult) -> Result<SessionState> {
+        match result {
+            InputResult::Correct => {
+                self.current_mistake_position = None;
+                Ok(SessionState::Continue)
             }
-        } else {
-            self.record_mistake();
+            InputResult::Incorrect => {
+                self.record_mistake();
+                Ok(SessionState::Continue)
+            }
+            InputResult::Completed => {
+                self.current_mistake_position = None;
+                Ok(SessionState::Complete)
+            }
+            InputResult::NoAction => Ok(SessionState::Continue),
         }
-
-        Ok(SessionState::Continue)
     }
 
     fn record_mistake(&mut self) {

src/game/typing_core.rs

@@ -427,4 +427,64 @@ impl TypingCore {
             }
         }
     }
+
+    // High-level input processing methods
+    pub fn process_character_input(&mut self, input_char: char) -> InputResult {
+        if !self.can_accept_input() {
+            return InputResult::NoAction;
+        }
+
+        if self.check_character_match(input_char) {
+            self.advance_to_next_character();
+            if self.is_completed() {
+                InputResult::Completed
+            } else {
+                InputResult::Correct
+            }
+        } else {
+            InputResult::Incorrect
+        }
+    }
+
+    pub fn process_enter_input(&mut self) -> InputResult {
+        if !self.can_accept_input() {
+            return InputResult::NoAction;
+        }
+
+        if self.is_at_line_end_for_enter() {
+            self.handle_newline_advance();
+            if self.is_completed() {
+                InputResult::Completed
+            } else {
+                InputResult::Correct
+            }
+        } else {
+            InputResult::Incorrect
+        }
+    }
+
+    pub fn process_tab_input(&mut self) -> InputResult {
+        if !self.can_accept_input() {
+            return InputResult::NoAction;
+        }
+
+        if self.check_character_match('\t') {
+            self.advance_to_next_character();
+            if self.is_completed() {
+                InputResult::Completed
+            } else {
+                InputResult::Correct
+            }
+        } else {
+            InputResult::Incorrect
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum InputResult {
+    Correct,      // Input was correct, continue
+    Incorrect,    // Input was incorrect (mistake)
+    Completed,    // Input was correct and typing is complete
+    NoAction,     // No input accepted (already completed)
 }