jueves, 2 de mayo de 2019

Creando videojuegos en Rust lang (Parte 21)

En el tiempo que ha pasado hubo una actualización en "rustup", nuestro administrador de herramientas de Rust. Para actualizarlo simplemente usamos el comando "rustup update" y obtenemos los resultados siguientes:


Como podemos ver estamos usando la versión estable de Rust 1.34.1. Este comando también actualizó otros componentes como cargo, clippy y rustfmt.

Aprovecharé esta entrada también para explicar un poco de las versiones de ggez. Como nota, en el momento que esta entrada fue escrita Crates.io (https://crates.io/crates/ggez) cuenta con las siguientes versiones de ggez: 0.4.3, 0.4.4, 0.5.0-rc.0, 0.5.0-rc.1 y 0.5.0-rc.0. Crates.io es la página de la cual cargo descarga lo que necesitamos cuando usamos "cargo build" o "cargo run". Al momento en que fue escrita esta entrada vemos que en la pagina de github de ggez (https://github.com/ggez/ggez) menciona que las versiones 0.5.0-rc.X no están terminadas, pero que se recomienda utilizarlas porque las funciones y métodos no cambiarán mucho cuando se libere la versión real. La desventaja es que la documentación pueden no estar actualizada y puede haber errores. En la Parte 4 y la Parte 20 usamos la versión 0.5.0-rc.1 de ggez.

En la entrada pasada imprimimos "dt", el intervalo entre actualizaciones. Este concepto de "dt" es muy útil para videojuegos y esta relacionado con los cuadros por segundo (fps o "frames per second"). Ahora procederemos a usar documentación de ggez para obtener los cuadros por segundo (fps) a los que opera nuestro programa. Servirá un ejemplo de como utilizar documentación.

1. Creamos un proyecto llamado "hello_ggez03" con "cargo new hello_ggez03"
2. Cambiamos el archivo toml para poner la dependencia a ggez:

1
2
3
4
5
6
7
8
[package]
name = "hello_ggez03"
version = "0.1.0"
authors = ["MiUsuario <micorreo@correo.com>"]
edition = "2018"

[dependencies]
ggez = "0.5.0-rc.1"

Si queremos ver la documentación de 0.5.0-rc.1 de ggez tenemos dos opciones:
  • La podemos ver en línea ya que docs.rs nos la pone disponible: https://docs.rs/ggez/0.5.0-rc.1/ggez/ Y en la esquina superior izquierda podemos cambiar la versión a la que busquemos. Podemos buscar "fps" y nos sugiere una función para calcular los cuadros por segundo promediando sobre los últimos 200 cuadros:
La documentación nos sugiere ggez::timer::fps
  • La segunda opción es usar el comando "cargo doc" que nos genera la documentación, útil si no tenemos conexión de internet:

Después de realizar su procesamiento podemos usar "cargo doc --open" y abrirá la documentación en nuestro navegador predeterminado:

Podemos encontrar la misma función ggez::timer::fps en la documentación generada por "cargo doc"
Al darle click a la función nos proporciona el nombre y las entradas. Nos menciona que toma una referencia no mutable de Contexto y que su salida es un f64.


Si en la imagen de arriba le damos click en "[src]" nos muestra el código fuente si está disponible. En este caso vemos lo siguiente:


Y con esto podemos entender la función más a detalle.

3. Ahora modificaremos ligeramente nuestro código de la entrada anterior (Parte 20 o "hello_ggez02") para que nos muestre fps en vez de dt:


 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
use ggez::*;

struct EstadoDelJuego {
    fps: f64
}

impl ggez::event::EventHandler for EstadoDelJuego {
    fn update(&mut self, 
            contexto: &mut Context) -> GameResult<()> {
        self.fps = ggez::timer::fps(&contexto);
        Ok(())
    }
    fn draw(&mut self, 
            _contexto: &mut Context) -> GameResult<()> {
        println!("Hola ggez! fps = {}", self.fps);
        Ok(())
    }
}

fn main() {
    let estado_del_juego = &mut EstadoDelJuego {
        fps: 0.0f64 };
    let configuracion = conf::Conf::new();
    let (ref mut contexto, 
         ref mut bucle_de_juego) = ContextBuilder::new(
            "hello_ggez", "autor")
        .conf(configuracion).build().unwrap();
    event::run(contexto, bucle_de_juego, 
               estado_del_juego).unwrap();
}

Al correrlo con "cargo run" el contador de fps tarda un momento en estabilizarse. Este es el resultado con "cargo run":


Y este es el resultado con "cargo run --release":


Esta cantidad de fps es una estimación pero queda claro que el número es muy alto porque no estamos haciendo mucho en nuestro programa. Es un bucle pero sin muchas operaciones. A base de esto podemos construir lógica para limitar los cuadros por segundo. A medida que realizamos más operaciones como dibujar más información y más lógica esto hará que la cantidad de fps sea menor.

Navegación:
Primera parte
Siguiente parte
Parte anterior

Fuente (inglés):



Publicadas por a la/s

No hay comentarios.:

Publicar un comentario

Suscribirse a: Comentarios de la entrada (Atom)