100sortRust

//Para Jogar de o comando no terminal:
//cargo new arrumeacasa
//Editar o cargo.toml e colocar abaixo de [dependencies]: 
//rand = "0.3.14"
//Copiar o codigo abaixo no src/main.rs
//Salvar e dar cargo run

extern crate rand;

use rand::Rng;
use std::io;

struct Game {
    board: [u32; 25],
    turn : u32,
}


fn main() {
    let mut game_ini = Game {
        board: [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
        turn : 0,
    };
    

    while game_ini.turn != 25 {

        let nro_rand = sorteia_nro(game_ini.board);
        monta_tela(game_ini.board);

        loop {
            let input = pergunta_casa(nro_rand);
        
            let mut char = input.chars();
            let linha = char.nth(0);
            let linha_str: String = linha.into_iter().collect();
            let coluna = char.nth(0);
            let coluna_str: String = coluna.into_iter().collect();
            let linha_u: u32 = linha_str.trim().parse().expect("!");
            let coluna_u: u32 = coluna_str.trim().parse().expect("!");
        
             //calcular casa pela linha e coluna
            let x = (linha_u - 1) * 5;
            let ind = (coluna_u - 1) + x;
            let indx: usize = ind as usize; 
            let nro_na_casa =  game_ini.board[indx];
            if nro_na_casa == 0 {
                game_ini.board = board_set(game_ini.board, indx, nro_rand);
                game_ini.turn = game_ini.turn + 1;
                break;
            };
        }
    }
    monta_tela(game_ini.board);
    let soma_pontos = verifica_final(game_ini.board);
    println!("Voce fez : {}  Pontos", soma_pontos);
}

fn sorteia_nro (board: [u32; 25]) -> u32 {
    let mut numero;
    loop {
        numero = rand::thread_rng().gen_range(1, 100);
        let mut nao_tem = true;
        //verifica se existe nro na tabela
                for idx in 0..25 {
                    let nro = board[idx];
                    if nro == numero {
                        nao_tem = false;
                    } 
                }
        if nao_tem == true {break;}
    } 
    numero
}

fn monta_tela(b: [u32; 25]) {
    //eu so acho q nao devia fazer assim, mas nao sei explicar porque e assim funciona
    println!(" ");
    // for ind in [0, 5, 10, 15, 20].iter() {
    //     //let i: usize = ind as usize; 
    //     println!(" {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[i]), m_t_a(b[i+1]), m_t_a(b[i+2]), m_t_a(b[i+3]), m_t_a(b[i+4]));
    //     println!("-------------------------");
    // };
    println!(" {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[0]), m_t_a(b[1]), m_t_a(b[2]), m_t_a(b[3]), m_t_a(b[4]));
    println!("-------------------------");
    println!(" {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[5]), m_t_a(b[6]), m_t_a(b[7]), m_t_a(b[8]), m_t_a(b[9]));
    println!("-------------------------");
    println!(" {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[10]), m_t_a(b[11]), m_t_a(b[12]), m_t_a(b[13]), m_t_a(b[14]));
    println!("-------------------------");
    println!(" {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[15]), m_t_a(b[16]), m_t_a(b[17]), m_t_a(b[18]), m_t_a(b[19]));
    println!("-------------------------");
    println!(" {:02} | {:02} | {:02} | {:02} | {:02}", m_t_a(b[20]), m_t_a(b[21]), m_t_a(b[22]), m_t_a(b[23]), m_t_a(b[24]));
    println!(" ");
    println!(" ");
}

fn m_t_a(nro: u32) -> String {
    if nro == 0 {
        let str: String = "--".to_string();
        str
    } else {
        let str: String = format!("{:>2}", nro).to_string();
        str
    }
}

fn pergunta_casa(nro_sort: u32) -> String {
    let mut retorno: String ;
    loop {
    let mut entrada = String::new();
    println!("Escolha uma linha e uma coluna pro Numero: {}", nro_sort);

    io::stdin().read_line(&mut entrada)
        .expect("Falha ao ler entrada");
    
    retorno = entrada.chars().filter(|c| c.is_digit(10)&& *c >= '1' && *c <= '5').collect();

    if retorno.len() > 1 {
        retorno = retorno.chars().take(2).collect();
        break;
        }
    }
    retorno
}

fn board_set(board: [u32; 25], idx: usize, nro: u32) -> [u32; 25] {
    let mut new_board = board;
    new_board[idx] = nro;
    new_board
}

fn verifica_final(board: [u32; 25]) -> u32 {
    let mut valor = 0;
    for linhas in 0..4 {
        if verifica_linha(linhas, board){
            let indice_lin = linhas * 5;
            let il: usize = indice_lin as usize; 
            valor = valor + board[il] + board[il+1] + board[il+2] + board[il+3] + board[il+4] 
        }
    };
    for colunas in 0..4 {
        if verifica_colun(colunas, board){
            let ic: usize = colunas as usize;
            valor = valor + board[ic] + board[ic+5] + board[ic+10] + board[ic+15] + board[ic+20] 
        }
    }
    valor
}

fn verifica_linha(lin: u32, board: [u32; 25]) -> bool {
    let indice_ini = lin * 5;
    let indice_fin = indice_ini + 4;
    let mut is_sort = true;
    for i in indice_ini..indice_fin {
        let idx: usize = i as usize; 
        if board[idx+1] < board[idx] {
            is_sort = false;
            break;
        } 
    };
    is_sort
}

fn verifica_colun(col: u32, board: [u32; 25]) -> bool {
    let mut is_sort = true;
        for i in [0, 5, 10, 15].iter() {
            let ind = col + i;
            let idx: usize = ind as usize; 
            if board[idx+5] < board[idx] {
                is_sort = false;
                break;
            } 
        };
    is_sort
}