Ir al contenido
Descargar
Curso de Grost

Cada frame

Módulo 3 · Grost en el juegoLección 11 de 208 min de lectura4 retos
main.groPaso 1 de 4
fn _ready() void {
  print("¡Gobi aparece!")
}1 · Una vez: _readyYa conoces _ready: Gobu la llama una sola vez, cuando el actor entra en la escena. Sirve para prepararlo todo.
Output
¡Gobi aparece!
main.groPaso 2 de 4
mut frames : int = 0

fn _ready() void {
  print("¡Gobi aparece!")
}

fn _process(_delta: float) void {
  frames += 1
  if frames == 60 {
    print("60 frames")2 · Cada frame: _processA _process la llama Gobu en cada frame, muchas veces por segundo. Aquí suma uno cada vez y avisa al llegar a 60.  }
}
Output
¡Gobi aparece!
60 frames
main.groPaso 3 de 4
mut frames : int = 0
mut tiempo : float = 0.0

fn _ready() void {
  print("¡Gobi aparece!")
}

fn _process(delta: float) void {
  frames += 1
  tiempo += delta3 · delta: el tiempo entre framesdelta son los segundos que han pasado desde el frame anterior. Si los sumas, sabes cuánto tiempo lleva el juego: aquí, 60 frames hacen un segundo.  if frames == 60 {
    print($"{frames} frames, {tiempo} segundos")
  }
}
Output
¡Gobi aparece!
60 frames, 1.0 segundos
main.groPaso 4 de 4
use actor::Gobi as gobi : Spatial2D

VELOCIDAD :: 120.0
mut frames : int = 0

fn _ready() void {
  print("¡Gobi aparece!")
}

fn _process(delta: float) void {
  gobi.position.x += VELOCIDAD * delta4 · Mover a GobiLa primera línea te da el actor Gobi (la próxima lección lo explica). En cada frame avanza VELOCIDAD * delta píxeles: en un segundo, 120.  frames += 1
  if frames == 60 {
    print(gobi.position.x)
  }
}
Output
¡Gobi aparece!
120.0
También con las flechas ← →

Un juego no es una foto: es una película. Gobi camina, los enemigos patrullan, el reloj de la partida baja. Todo eso pasa poco a poco, a lo largo del tiempo.

En esta lección aprendes dónde va el código que se repite una y otra vez mientras el juego corre, y cómo usarlo para mover y contar cosas.

El bucle del juego

Un juego se dibuja muchas veces por segundo, como las páginas de un libro animado que pasas rápido. Cada una de esas imágenes es un frame. Antes de dibujar cada frame, Gobu deja que cada actor se actualice: que se mueva, que cuente, que compruebe cosas. A esa repetición se le llama el bucle del juego.

Para que tu código entre en ese bucle, escribe una función _process:

main.gro
module Contador
mut frames : int = 0
fn _ready() void {
print("¡Empieza!")
}
fn _process(_delta: float) void {
frames += 1
if frames == 60 {
print("Ya van 60 frames")
}
if frames == 120 {
print("Y 120")
}
}
Output¡Empieza! Ya van 60 frames Y 120
  • frames está fuera de las funciones: es una variable del script, así que recuerda su valor de un frame al siguiente.
  • _process le suma uno en cada frame, y avisa al llegar a 60 y a 120.
  • Su parámetro se llama _delta, con guion bajo, porque aquí no lo usamos. Enseguida verás qué es.
¿Cuántos frames hay en un segundo?

Depende del ordenador y de la pantalla. Muchas pantallas muestran 60 por segundo, pero hay equipos que van a 30 y pantallas que llegan a 144. Por eso contar frames no sirve para medir el tiempo: para eso está delta.

_ready y _process

Las dos funciones las llama Gobu por su cuenta, pero en momentos distintos:

FunciónCuándo la llama GobuPara qué sirve
_ready()Una vez, cuando el actor entra en la escenaPreparar: valores iniciales, mensajes de inicio
_process(delta)En cada frame, mientras el actor sigue en la escenaLo que cambia con el tiempo: moverse, contar, comprobar
main.gro
module Orden
mut frames : int = 0
fn _ready() void {
print("_ready: una vez")
}
fn _process(_delta: float) void {
frames += 1
if frames <= 3 {
print($"_process: frame {frames}")
}
}
Output_ready: una vez _process: frame 1 _process: frame 2 _process: frame 3

_ready va siempre primero. Después, _process se repite frame tras frame. Aquí solo imprimimos los tres primeros para no llenar el Output.

delta: el tiempo entre frames

_process recibe un número, delta: los segundos que han pasado desde el frame anterior. A 60 frames por segundo, cada frame dura 1/60 de segundo:

main.gro
module Delta
mut primero : bool = true
fn _ready() void {
print("Midiendo...")
}
fn _process(delta: float) void {
if primero {
primero = false
print(delta)
}
}
OutputMidiendo... 0.01666666666667

Si vas sumando delta en una variable, sabes cuánto tiempo ha pasado de verdad, vaya el juego a 30, a 60 o a 144 frames por segundo.

Mover a Gobi

Para mover un actor cambias su posición, position. Es un Vector2: dos números, x para la horizontal (crece hacia la derecha) e y para la vertical.

main.gro
module Gobi
use actor::Gobi as gobi : Spatial2D
VELOCIDAD :: 120.0 # píxeles por segundo
mut frames : int = 0
fn _ready() void {
print(gobi.position)
}
fn _process(delta: float) void {
gobi.position.x += VELOCIDAD * delta
frames += 1
if frames == 60 {
print(gobi.position)
}
}
Output(0.0, 0.0) (120.0, 0.0)
  • use actor::Gobi as gobi : Spatial2D te da el actor Gobi de la escena con el nombre gobi. Spatial2D es su tipo: un actor 2D con posición. La próxima lección explica use a fondo.
  • VELOCIDAD * delta es lo que avanza en este frame: 120 × 0.0167, unos 2 píxeles.
  • En 60 frames, un segundo, avanza 120 píxeles: justo su velocidad.

Contar el tiempo

Con delta también puedes medir segundos. Esta cuenta atrás avisa una vez por segundo y, al terminar, le dice a Gobu que deje de llamar a _process:

main.gro
module CuentaAtras
use actor::Gobi as gobi : Spatial2D
mut segundos : int = 3
mut tiempo : float = 0.0
fn _ready() void {
print(segundos)
}
fn _process(delta: float) void {
tiempo += delta
if tiempo >= 1.0 {
tiempo -= 1.0
segundos -= 1
if segundos > 0 {
print(segundos)
} else {
print("¡Ya!")
gobi.set_process(false)
}
}
}
Output3 2 1 ¡Ya!
  • tiempo acumula los delta. Cada vez que pasa de un segundo, le restamos 1.0 (en lugar de ponerlo a cero, para no perder el trocito que sobra) y descontamos un segundo.
  • gobi.set_process(false) le dice a Gobu que no vuelva a llamar a _process en este actor.
¿Y _physics_process?

Gobu también llama a _physics_process(delta), pensada para la física: cuerpos que se mueven y chocan, como un personaje que camina sobre el suelo. Se escribe igual que _process.

Hora de practicar

Retos: 0/4 resueltosSe guardan en este navegador
Reto 1 de 4sin resolver

¿Cuántas veces llama Gobu a cada función?

_ready corre una vez, cuando el actor entra en la escena. _process corre en cada frame mientras el actor sigue en ella.
Una sirve para preparar el actor y la otra para lo que cambia con el tiempo.
Reto 2 de 4sin resolver

Completa el código para que Gobi avance 100 píxeles por segundo.

main.gro
use actor::Gobi as gobi : Spatial2D

fn (delta: float) void {
  gobi.position.x += 100.0 * 
}
El primer hueco es la función que Gobu llama en cada frame. El segundo, los segundos que han pasado desde el frame anterior.
Solución:
main.gro
use actor::Gobi as gobi : Spatial2D

fn _process(delta: float) void {
  gobi.position.x += 100.0 * delta
}
Reto 3 de 4sin resolver

¿Qué imprime este código?

main.gro
mut frames : int = 0

fn _ready() void {
  print("empieza")
}

fn _process(_delta: float) void {
  frames += 1
  if frames == 1 {
    print("primer frame")
  }
}
_ready corre primero, al entrar en la escena. Luego empieza el bucle del juego y en el primer frame _process imprime su mensaje.
Piensa en cuál de las dos funciones llama Gobu antes.
Reto 4 de 4sin resolver

Si el juego va a 60 frames por segundo, ¿cuánto vale delta más o menos?

Cada frame dura 1/60 de segundo, que es más o menos 0.0167.
delta se mide en segundos y es lo que dura un solo frame.