mints 0.1.1

A crate containing a few simple command-line procrastination 'tools' :)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use std::{collections::HashMap, io::Write, time::Duration};

use crate::wordle::Wordle;
use colored::Colorize;
use terminal_size::{terminal_size, Width};

use mints::*;

pub struct Display;

pub enum DisplayType {
    Start,
    GameBoard,
    Victory,
    Failure,
}

impl Display {
    pub fn display(display: DisplayType, game: &Wordle) {
        // Clear terminal
        print!("{}[2J", 27 as char);
        newln!();

        let term_width = if let Some((Width(w), _)) = terminal_size() {
            w as usize
        } else {
            80 // Default width in case terminal size can't be determined
        };

        let header_text = match display {
            DisplayType::Start => " Wordle! ".to_string(),
            DisplayType::GameBoard => format!(" Round {} ", game.turn + 1),
            DisplayType::Victory => " You Won! ".to_string(),
            DisplayType::Failure => format!(" The word was {}! ", game.answer),
        };

        // Calculate padding
        let text_width = header_text.len() + (game.max_letters as usize * 2); // Adding 10 for the side indicators ("== ", " ==")
        let padding_length = term_width / 2 - text_width / 2;
        let padding = "=".repeat(padding_length);

        // Print header with padding
        println!("{}{}{}", padding, header_text.bold(), padding);

        for index in 0..game.max_guesses {
            Self::print_row(game, index);
        }

        newln!();
    }

    fn print_row(game: &Wordle, index: i32) {
        let term_width = if let Some((Width(w), _)) = terminal_size() {
            w as usize
        } else {
            80 // Default width in case terminal size can't be determined
        };

        let padding_length = term_width / 2 - game.max_letters as usize * 3;
        let padding = "=".repeat(padding_length);

        print!("{}", padding);

        let sides = if index == game.turn {
            (">> ", " <<")
        } else {
            ("== ", " ==")
        };

        print!("{}", sides.0);

        if let Some(guess) = game
            .guesses
            .get(&index)
            .expect("Guess does not exist at turn index")
        {
            let mut answer_map = HashMap::new();
            // First, count all letters in the answer
            for c in game.answer.chars() {
                *answer_map.entry(c).or_insert(0) += 1;
            }

            // First pass: Check for correct position (green)
            let guess_chars: Vec<char> = guess.chars().collect();
            let mut correctness = vec![false; guess.len()];

            for (i, &c) in guess_chars.iter().enumerate() {
                if game.answer.chars().nth(i) == Some(c) {
                    correctness[i] = true;
                    *answer_map.get_mut(&c).unwrap() -= 1;
                }
            }

            // Second pass: Check for correct letters in wrong positions (yellow)
            for (i, &c) in guess_chars.iter().enumerate() {
                if correctness[i] {
                    print!(" {} ", c.to_string().green());
                } else if answer_map.get(&c).unwrap_or(&0) > &0 {
                    print!(" {} ", c.to_string().yellow());
                    *answer_map.get_mut(&c).unwrap() -= 1;
                } else {
                    print!(" {} ", c.to_string());
                }

                if index == game.turn - 1 {
                    std::thread::sleep(Duration::from_millis(300));
                    std::io::stdout().flush().expect("Failed to flush stdout");
                }
            }
        } else {
            for _ in 0..game.max_letters {
                print!(" _ ");
            }
        }

        print!("{}", sides.1);
        print!("{}", padding);
        newln!();
    }
}