Cada frame
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.¡Gobi aparece!
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. }
}¡Gobi aparece! 60 frames
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")
}
}¡Gobi aparece! 60 frames, 1.0 segundos
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)
}
}¡Gobi aparece! 120.0
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:
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") }}framesestá fuera de las funciones: es una variable del script, así que recuerda su valor de un frame al siguiente._processle 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ón | Cuándo la llama Gobu | Para qué sirve |
|---|---|---|
_ready() | Una vez, cuando el actor entra en la escena | Preparar: valores iniciales, mensajes de inicio |
_process(delta) | En cada frame, mientras el actor sigue en la escena | Lo que cambia con el tiempo: moverse, contar, comprobar |
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}") }}_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:
module Delta
mut primero : bool = true
fn _ready() void { print("Midiendo...")}
fn _process(delta: float) void { if primero { primero = false print(delta) }}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.
module Gobi
use actor::Gobi as gobi : Spatial2D
VELOCIDAD :: 120.0 # píxeles por segundomut 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) }}use actor::Gobi as gobi : Spatial2Dte da el actorGobide la escena con el nombregobi.Spatial2Des su tipo: un actor 2D con posición. La próxima lección explicausea fondo.VELOCIDAD * deltaes 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:
module CuentaAtras
use actor::Gobi as gobi : Spatial2D
mut segundos : int = 3mut 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) } }}tiempoacumula losdelta. Cada vez que pasa de un segundo, le restamos1.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_processen 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
¿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.Completa el código para que Gobi avance 100 píxeles por segundo.
use actor::Gobi as gobi : Spatial2D
fn (delta: float) void {
gobi.position.x += 100.0 *
}use actor::Gobi as gobi : Spatial2D
fn _process(delta: float) void {
gobi.position.x += 100.0 * delta
}¿Qué imprime este código?
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.Si el juego va a 60 frames por segundo, ¿cuánto vale delta más o menos?
delta se mide en segundos y es lo que dura un solo frame.