numberplace-rs

main.rs (6917B)

---

 mod board;
 
 use board::{Board, GRID_SIZE};
 use crossterm::{
     event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
     execute,
     terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
 };
 use ratatui::{
     Frame, Terminal,
     backend::{Backend, CrosstermBackend},
     layout::{Constraint, Direction, Layout, Rect},
     style::{Color, Modifier, Style},
     text::{Line, Span},
     widgets::{Block, Borders, Paragraph},
 };
 use std::io;
 
 struct App {
     board: Board,
     cursor: (usize, usize), // (row, col)
 }
 
 impl App {
     fn new() -> Self {
         let mut board = Board::new();
         board.generate();
         Self {
             board,
             cursor: (0, 0),
         }
     }
 
     fn move_cursor(&mut self, row_delta: isize, col_delta: isize) {
         if self.board.is_solved() {
             return;
         }
         let new_row =
             (self.cursor.0 as isize + row_delta).clamp(0, (GRID_SIZE - 1) as isize) as usize;
         let new_col =
             (self.cursor.1 as isize + col_delta).clamp(0, (GRID_SIZE - 1) as isize) as usize;
         self.cursor = (new_row, new_col);
     }
 
     fn set_cell_value(&mut self, val: Option<u8>) {
         if self.board.is_solved() {
             return;
         }
         self.board.set_value(self.cursor.0, self.cursor.1, val);
     }
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     enable_raw_mode()?;
     let mut stdout = io::stdout();
     execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
     let backend = CrosstermBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
 
     let mut app = App::new();
     let res = run_app(&mut terminal, &mut app);
 
     disable_raw_mode()?;
     execute!(
         terminal.backend_mut(),
         LeaveAlternateScreen,
         DisableMouseCapture
     )?;
     terminal.show_cursor()?;
 
     if let Err(err) = res {
         eprintln!("{:?}", err)
     }
 
     Ok(())
 }
 
 fn run_app<B: Backend>(
     terminal: &mut Terminal<B>,
     app: &mut App,
 ) -> Result<(), Box<dyn std::error::Error>>
 where
     B::Error: std::error::Error + 'static,
 {
     loop {
         terminal.draw(|f| ui(f, app))?;
 
         if let Event::Key(key) = event::read()? {
             match key.code {
                 KeyCode::Char('q') => return Ok(()),
                 KeyCode::Char('n') if app.board.is_solved() => {
                     app.board.generate();
                     app.cursor = (0, 0);
                 }
                 KeyCode::Char('s') => {
                     app.board.solve();
                 }
                 KeyCode::Char('h') | KeyCode::Left => app.move_cursor(0, -1),
                 KeyCode::Char('j') | KeyCode::Down => app.move_cursor(1, 0),
                 KeyCode::Char('k') | KeyCode::Up => app.move_cursor(-1, 0),
                 KeyCode::Char('l') | KeyCode::Right => app.move_cursor(0, 1),
                 KeyCode::Char(c) if c.is_digit(10) => {
                     let val = c.to_digit(10).unwrap() as u8;
                     if val == 0 {
                         app.set_cell_value(None);
                     } else {
                         app.set_cell_value(Some(val));
                     }
                 }
                 KeyCode::Char('x') | KeyCode::Backspace => app.set_cell_value(None),
                 _ => {}
             }
         }
     }
 }
 
 fn ui(f: &mut Frame, app: &App) {
     let chunks = Layout::default()
         .direction(Direction::Vertical)
         .constraints([Constraint::Min(13), Constraint::Length(3)].as_ref())
         .split(f.area());
 
     draw_board(f, chunks[0], app);
     draw_help(f, chunks[1], app.board.is_solved());
 }
 
 fn draw_board(f: &mut Frame, area: Rect, app: &App) {
     let board_width = 9 * 2 + 2;
     let board_height = 9 + 2;
 
     let board_area = Rect::new(
         area.x + (area.width.saturating_sub(board_width as u16)) / 2,
         area.y + (area.height.saturating_sub(board_height as u16)) / 2,
         board_width as u16,
         board_height as u16,
     );
 
     let block = Block::default().borders(Borders::ALL).title(" Sudoku ");
     f.render_widget(block, board_area);
 
     let inner = board_area.inner(ratatui::layout::Margin {
         vertical: 1,
         horizontal: 1,
     });
 
     for r in 0..GRID_SIZE {
         for c in 0..GRID_SIZE {
             let cell = app.board.cells[r][c];
             let is_cursor = (r, c) == app.cursor;
             let is_conflict = app.board.is_conflict(r, c);
 
             let mut style = Style::default();
             if cell.is_fixed {
                 style = style.add_modifier(Modifier::BOLD);
             } else {
                 style = style.fg(Color::Cyan);
             }
 
             if is_conflict {
                 style = style.bg(Color::Red).fg(Color::White);
             }
 
             if is_cursor {
                 style = style.bg(Color::White).fg(Color::Black);
             }
 
             let text = match cell.value {
                 Some(v) => v.to_string(),
                 None => " ".to_string(),
             };
 
             let x_offset = c as u16 * 2;
 
             f.render_widget(
                 Paragraph::new(text).style(style),
                 Rect::new(inner.x + x_offset, inner.y + r as u16, 1, 1),
             );
 
             if c % 3 == 2 && c < 8 {
                 f.render_widget(
                     Paragraph::new("│").style(Style::default().fg(Color::DarkGray)),
                     Rect::new(inner.x + x_offset + 1, inner.y + r as u16, 1, 1),
                 );
             }
         }
     }
 }
 
 fn draw_help(f: &mut Frame, area: Rect, solved: bool) {
     let help_text = if solved {
         vec![Line::from(vec![
             Span::styled(
                 "CONGRATULATIONS! ",
                 Style::default()
                     .fg(Color::Yellow)
                     .add_modifier(Modifier::BOLD),
             ),
             Span::raw("Press "),
             Span::styled("n", Style::default().add_modifier(Modifier::BOLD)),
             Span::raw(" for new game, "),
             Span::styled("q", Style::default().add_modifier(Modifier::BOLD)),
             Span::raw(": quit"),
         ])]
     } else {
         vec![Line::from(vec![
             Span::styled("hjkl/Arrows", Style::default().add_modifier(Modifier::BOLD)),
             Span::raw(": move, "),
             Span::styled("1-9", Style::default().add_modifier(Modifier::BOLD)),
             Span::raw(": input, "),
             Span::styled("x/0/BS", Style::default().add_modifier(Modifier::BOLD)),
             Span::raw(": delete, "),
             Span::styled("s", Style::default().add_modifier(Modifier::BOLD)),
             Span::raw(": solve, "),
             Span::styled("q", Style::default().add_modifier(Modifier::BOLD)),
             Span::raw(": quit"),
         ])]
     };
     let help =
         Paragraph::new(help_text).block(Block::default().borders(Borders::ALL).title(" Help "));
     f.render_widget(help, area);
 }