rust-code01

const MINA: &str = "*";
const ESPACIO_SIN_ABRIR: &str = ".";
const ESPACIO_ABIERTO: &str = "-";
const LETRAS: &str = "ABCDEF";
const FILAS: i32 = LETRAS.len();
const COLUMNAS: i32 = 6;
static mut tablero : Vec<i32> = Vec::new();
const HA_GANADO: bool = false;
const HA_PERDIDO: bool = false;


fn inicializar_tablero(){
   
    let mut tablero : Vec<i32> = Vec::new();
    /*
    Rellena el tablero
    */
    for fila in (0..FILAS){
        tablero.push([]);
        for columna in 0..COLUMNAS{
            tablero[fila].push(ESPACIO_SIN_ABRIR);
        }
    }
}    


fn numero_a_letra(numero: i32) -> String{
    /*
    Convierte el número (comenzando en 0) a la letra
    */
    return LETRAS[numero];
}

fn index(x: &str) -> i32{
    if (x == 'a' || x == 'A'){
        return 0;
    }else if (x == 'b' || x == 'B'){
        return 1;
    }else if(x == 'c' || x == 'C') {
        return 2;
    }else if(x == 'd' || x == 'D') {
        return 3;
    }else if(x == 'e' || x == 'E') {
        return 4;
    }else if(x == 'f' || x == 'F') {
        return 5;
    }else if(x == 'g' || x == 'G') {
        return 6;
    }else if(x == 'h' || x == 'H') {
        return 7;
    }else if(x == 'i' || x == 'I') {
        return 8;
    }else if(x == 'j' || x == 'J') {
        return 9;}
}

fn letra_a_numero(letra: &str) -> i32{
    /*
    Devuelve el número que le corresponde a la letra COMENZANDO EN 0. Por ejemplo
    A: 0
    B: 1
    
    Nota: si en algún momento se deseara que el tablero fuera más grande, solo sería cuestión de agregar más letras a la cadena"""
    */
    let numero: i32 = LETRAS.index(letra);
    return numero;
}    


fn obtener_indices_a_partir_de_coordenadas(coordenadas: &str) -> i32{

    /*
    Devuelve, a partir de una coordenada como A1, las coordenadas
    reales de la matriz; es decir, los índices. Por ejemplo, para
    A1 devolvería [0, 0]
    */
    let letra: String = coordenadas[0:1];
    let fila: i32 = letra_a_numero(letra);
    let columna: i32 = int(coordenadas[1:2]) - 1;
    return fila, columna;
}  


fn colocar_minas_en_tablero(posiciones: i32){

    let mut tablero : Vec<i32> = new Vec::new();

      for posicion in 0..posiciones:
        let fila: i32 = obtener_indices_a_partir_de_coordenadas(posicion);
        let columna: i32 = obtener_indices_a_partir_de_coordenadas(posicion);
        tablero[fila][columna] = MINA;
}  


fn iniciar_tablero_con_string(posiciones_string: &vec<String>) -> i32{

    // Convertimos a mayúscula para que podamos comparar de mejor manera"""

    let mut posiciones_string: String = posiciones_string.upper();
    let mut posiciones_separadas : Vec<i32> = new Vec::new();

    let primera_posicion: &i32 = &posiciones_string[2]; //"""posiciones_string[0:2];"""
    let segunda_posicion: &i32 = &posiciones_string[4]; //"""posiciones_string[2:4];"""
    let tercera_posicion: &i32= &posiciones_string[6];  //"""posiciones_string[4:6];"""

    if !primera_posicion in 0..posiciones_separadas:
        posiciones_separadas.push(primera_posicion);
    if !segunda_posicion in 0..posiciones_separadas:
        posiciones_separadas.push(segunda_posicion);
    if !tercera_posicion in 0..posiciones_separadas:
        posiciones_separadas.push(tercera_posicion);

    colocar_minas_en_tablero(posiciones_separadas);
}  


fn obtener_minas_cercanas(fila: i32, columna: i32) -> String{

    let conteo: i32 = 0;
    let mut tablero : Vec<i32> = new Vec::new();

    if fila <= 0:
        let fila_inicio: i32 = 0;
    else:
        let fila_inicio: i32 = fila - 1;


    if fila + 1 >= FILAS:
        let fila_fin: i32 = FILAS - 1;
    else:
        let fila_fin: i32 = fila + 1;


    if columna <= 0:
        let columna_inicio: i32 = 0;
    else:
        let columna_inicio: i32 = columna - 1;



    if columna + 1 >= COLUMNAS:
        let columna_fin: i32 = COLUMNAS - 1;
    else:
        let columna_fin: i32 = columna + 1;



    for f in fila_inicio..fila_fin + 1:
        for c in columna_inicio..columna_fin + 1:
            //""" Si es la central, la omitimos"""
            if f == fila && c == columna:
                ...continue;

            if tablero[f][c] == MINA:
                conteo += 1;

    let conteoS: String = conteo.to_string();

    return conteoS;
}
   

fn imprimir_tablero() -> String{

    println!("");
    let ultima_casilla: bool = false;
    //""" Imprimir esquina superior izquierda"""
    println!("  ", end="");


    //""" Imprimir resto de encabezado"""
    let columna: i32;    
    for columna in 0..COLUMNAS:        
        println!(let columnaS: Strig = (columna + 1).to_string(), end=" ");
        //""" Salto de línea"""
    println!("");

    //""" Imprimir contenido..."""
    let numero_fila: i32 = 0;
    let mut tablero : Vec<i32> = new Vec::new();

    for fila in 0..tablero:
        let letra: String = numero_a_letra(numero_fila);
        println!(letra, end=" ");
        for (numero_columna, dato) in 0..fila.enumerate():
        """El tablero tiene los verdaderos datos, pero nosotros imprimimos otros para que el usuario no "descubra" lo que hay debajo"""
            let verdadero_dato: Strig = "";
            let dato: Strig;
            let numero_fila : Strig;
            let numero_columna: String;

            if dato == MINA:
                if HA_GANADO || HA_PERDIDO:
                    verdadero_dato = MINA;
                else:
                    verdadero_dato = ESPACIO_SIN_ABRIR:
            else if dato == ESPACIO_ABIERTO:
                verdadero_dato = obtener_minas_cercanas(numero_fila, numero_columna);
            else if dato == ESPACIO_SIN_ABRIR:
                verdadero_dato = ".";

            println!(verdadero_dato, end=" ");
        println!("");
        numero_fila += 1;

    if HA_GANADO:
        println!("GANASTE");
    else if HA_PERDIDO:
        println!("PERDISTE");
}  

fn abrir_casilla(coordenadas: &str) -> bool{

    let mut tablero : Vec<i32> = new Vec::new();

    let fila: i32 = obtener_indices_a_partir_de_coordenadas(coordenadas);
    let columna: i32 = obtener_indices_a_partir_de_coordenadas(coordenadas);

    """ Qué había en la casilla?"""
    let mut elemento_actual: Vec<i32> = tablero[fila][columna];
    """ Si hay una mina, pierde y ya no se modifica nada"""
    if elemento_actual == MINA:
        HA_PERDIDO = true;
        return;

        """ Si es un elemento sin abri, lo abre"""
    if elemento_actual == ESPACIO_SIN_ABRIR:
        tablero[fila][columna] = ESPACIO_ABIERTO;
        """ Comprobamos si hay casillas sin abrir"""
    if no_hay_casillas_sin_abrir():
        HA_GANADO = true;
}

fn no_hay_casillas_sin_abrir() -> bool{

    let mut tablero : Vec<i32> = new Vec::new();    
    let fila: i32;
    let columna: i32;

    for fila in 0..tablero:
        for columna in 0..fila:
            if columna == ESPACIO_SIN_ABRIR:
                return false;
    return true;
}

fn solicitar_coordenadas() -> String{

    let coordenadas: String;
    while true:
    coordenadas = input("Ingresa el string con las posiciones de las minas: ");
    if coordenadas.len() == COLUMNAS:
        return coordenadas;
    else:
        println!("Coordenadas no válidas. Intenta de nuevo");
}  


fn solicitar_casilla() -> String{

    let casilla: String;

    while true:
        casilla = input("Ingresa la casilla del tablero que quieres abrir: ")
        casilla = casilla.upper();

        if casilla.len() != 2:
            println!("Debes introducir una letra y un número");
            ...continue;
        if !casilla[0].is_alphabetic():
            println!("El primer valor debe ser una letra");
            ...continue;
        if !casilla[1].is_digit():
            println!("El segundo valor debe ser un número");
            ...continue;
        if !casilla[0] in 0..LETRAS:
            println!("La letra debe estar en el rango " + LETRAS);
            ...continue;
        if (casilla[1]).parse().unwrap() <= 0 || (casilla[1]).parse().unwrap() > COLUMNAS:
            println!("El número debe estar en el rango 1-{COLUMNAS}");
            ...continue;
        return casilla;

}

fn main(){

    inicializar_tablero();
    let coordenadas: String = solicitar_coordenadas();
    iniciar_tablero_con_string(coordenadas);
    imprimir_tablero();

    while !HA_PERDIDO && !HA_GANADO:
        let casilla: String = solicitar_casilla();
        abrir_casilla(casilla);
        imprimir_tablero();
}