Creando videojuegos en Rust lang (Parte 10)

Programa 4. "pre_hello_ggez4" Creando estructuras de datos: "structs"
Las estructuras de datos o los "structs" son formas de agrupar diferentes tipos de datos bajo un mismo nombre para poder procesarlos usando etiquetas. Son importantes en los videojuegos porque los structs se pueden guardar en la memoria estática ("stack") al contrario de la memoria dinámica ("heap"). Usar memoria estática es a veces deseable para mejorar el desempeño del programa. Un struct puede contener diferentes tipos de datos por lo cual es muy versátil en su uso.

En este código usamos un struct para guardar el estado de nuestro juego con información de Identificador (ID) del jugador, el nombre del jugador, la posición (x,y) del jugador y un "char" de identificación, ponemos valores iniciales e imprimimos los valores:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

struct EstadoDelJuego { id_jugador: u32, nombre_jugador: String, x: i32, y: i32, id_char: char } fn main() { let mi_juego = EstadoDelJuego{id_jugador: 1, nombre_jugador: String::from("Jugador 1"), x: 10, y: 5, id_char: 'a'}; println!("Valor id_jugador: {}", mi_juego.id_jugador); println!("Valor nombre_jugador: {}", mi_juego.nombre_jugador); println!("Valor x: {}", mi_juego.x); println!("Valor y: {}", mi_juego.y); println!("Valor id_char: {}", mi_juego.id_char); }

El resultado de correr el programa es el siguiente:

Vemos como para imprimirlo tuvimos que utilizar un punto (".") para llamar por la etiqueta el valor que queremos de nuestro estado del juego (ejemplo, "mi_juego.x"). Esto es porque no podemos imprimir el "struct" directamente. Nos marca un error si intentamos correr el siguiente código:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

struct EstadoDelJuego { id_jugador: u32, nombre_jugador: String, x: i32, y: i32, id_char: char } fn main() { let mi_juego = EstadoDelJuego{id_jugador: 1, nombre_jugador: String::from("Jugador 1"), x: 10, y: 5, id_char: 'a'}; println!("mi_juego: {}", mi_juego); }

Es decir que no podemos imprimirlo a menos que le quede claro a Rust como imprimirlo. Una opción es heredar las impresiones internas. Es decir, si todos los componentes dentro del struct tienen una forma de imprimirse en modo debug entonces podemos activar este modo especial para el struct. Para hacer esto seguimos la indicación del mensaje de error. Si intentamos usar "{:?}" ahora nos dice lo siguiente:

Como se puede ver en la imagen nos da dos opciones agregar "#[derive(Debug)]" o implementar manualmente "std::fmt:Debug". En este ejemplo sólo veremos la primera opción y más adelante veremos la segunda opción. Es simplemente cuestión de agregar #[derive(Debug)] antes de la definición de nuestro struct. También podemos usar "{:#?}" para que lo imprima en un formato más amigable. El resultado es el siguiente:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

#[derive(Debug)] struct EstadoDelJuego { id_jugador: u32, nombre_jugador: String, x: i32, y: i32, id_char: char } fn main() { let mi_juego = EstadoDelJuego{id_jugador: 1, nombre_jugador: String::from("Jugador 1"), x: 10, y: 5, id_char: 'a'}; println!("mi_juego: {:?}", mi_juego); println!("mi_juego: {:#?}", mi_juego); }

De esta forma podemos ver el struct impreso como si lo viéramos en el código. La otra opción que mencionó el compilador de implementar manualmente "std::fmt:Debug" lo veremos cuando entremos al tema de "traits" e implementación ("impl").

Navegación:
Primera parte
Siguiente parte
Parte anterior