Ir al contenido
Descargar
Curso de Grost

Anotaciones

Módulo 4 · Herramientas de juegoLección 20 de 209 min de lectura4 retos
main.groPaso 1 de 4
@editable mut velocidad : float = 5.01 · Una variable en el inspectorUna **anotación** empieza por @ y va delante de una declaración. @editable muestra la variable en el inspector del actor.
fn _ready() void {
  print(velocidad)
}
Output
5.0
main.groPaso 2 de 4
@editable mut velocidad : float = 5.0

fn _ready() void {
  print(velocidad)2 · El inspector mandaEn esta escena, el inspector del actor tiene velocidad a 8. El código es el mismo, pero el valor ya no es el de por defecto.}
Output
8.0
main.groPaso 3 de 4
@options("Fácil", "Normal", "Difícil") mut dificultad : int = 13 · Un desplegable@options muestra un desplegable con esas opciones. El valor es la posición de la elegida, empezando en 0: 1 es "Normal".
fn _ready() void {
  print(dificultad)
}
Output
1
main.groPaso 4 de 4
use actor::Jugador as jugador : Spatial2D

@onready mut inicio : Vector2 = jugador.position4 · Esperar al actor: @onready@onready da el valor a la variable cuando el actor ya está listo, justo antes de _ready. Sin ella, jugador todavía no se encontraría.
fn _ready() void {
  print(inicio)
}
Output
(10.0, 20.0)
También con las flechas ← →

Ya has visto alguna palabra que empieza por @, como @persistent en la lección de guardar partida. Son anotaciones: van delante de una declaración y no cambian lo que hace el código. Le dicen algo al editor o al motor: “muestra esto en el inspector”, “dale valor a esto cuando el actor esté listo”, “guarda esto”.

En esta lección ves las que más vas a usar.

@editable: valores en el inspector

Tienes un prefab de enemigo y quieres uno lento y otro rápido, sin escribir dos scripts. Marca la velocidad con @editable:

main.gro
module Enemigo
@editable mut velocidad : float = 5.0
fn _ready() void {
print(velocidad)
}
Output5.0

La variable aparece en el inspector del actor, el panel donde ves y cambias sus propiedades. El valor del código es el de por defecto: cada actor que usa el script puede cambiarlo en el inspector sin tocar el código. Este es el mismo script en un actor que, en el inspector, tiene velocidad a 8:

main.gro
module Enemigo
@editable mut velocidad : float = 5.0
fn _ready() void {
print(velocidad)
}
Output8.0
  • Declárala con mut: el inspector la cambia.
  • Su tipo decide el control del inspector: un campo numérico, una casilla para un bool, un selector para un Color…
main.gro
module Enemigo
@export mut velocidad : float = 5.0
fn _ready() void {
print(velocidad)
}
OutputParse Error: Unrecognized annotation: "@export".

Pistas para el inspector

Hay variantes de @editable que muestran un control más cómodo. Todas hacen la variable editable, igual que @editable:

main.gro
module Ajustes
@range(0, 100, 1) mut volumen : int = 50
@options("Fácil", "Normal", "Difícil") mut dificultad : int = 1
@multiline mut descripcion : String = "Un slime verde"
@no_alpha mut tinte : Color = Color.WHITE
fn _ready() void {
print(volumen)
print(dificultad)
print(descripcion)
}
Output50 1 Un slime verde
AnotaciónMuestra
@range(mín, máx, paso)Un deslizador entre esos dos números
@options("A", "B", ...)Un desplegable; el valor es la posición de la opción (int)
@multilineUn cuadro de texto grande
@no_alphaUn selector de color sin transparencia
@file("*.json")Un selector de archivo; el valor es su ruta

Un enum tuyo como tipo de la variable también da un desplegable.

Ordenar el inspector: grupos

Cuando un actor tiene muchos valores editables, agrúpalos. Todo lo que va después de @group entra en ese grupo, y lo que va después de @subgroup, en un subgrupo dentro de él:

main.gro
module Jugador
@group("Movimiento")
@editable mut velocidad : float = 5.0
@editable mut salto : float = 8.0
@subgroup("Aire")
@editable mut control_aire : float = 0.3
fn _ready() void {
print($"{velocidad} {salto} {control_aire}")
}
Output5.0 8.0 0.3

Los grupos solo cambian cómo se ve el inspector: en el código, las variables se usan igual.

@onready: esperar a que el actor esté listo

El valor inicial de una variable del script se calcula cuando el script arranca, antes de que el actor esté en la escena. Si ese valor depende de otro actor, todavía no puedes leerlo. @onready lo retrasa hasta que el actor está listo, justo antes de _ready:

main.gro
module Nivel
use actor::Jugador as jugador : Spatial2D
@onready mut inicio : Vector2 = jugador.position
fn _ready() void {
print(inicio)
}
Output(10.0, 20.0)

En esta escena, Jugador es un actor hijo colocado en (10, 20). Sin @onready, la línea de inicio falla: jugador todavía no se puede encontrar.

En un watch, @onready hace además que el bloque se ejecute una vez al empezar, con el valor actual, y no solo con el primer cambio.

No juntes @onready y @editable en la misma variable. El valor del inspector se aplica primero, y @onready lo pisaría después con el de por defecto. Grost no te deja:

main.gro
module Enemigo
@onready @editable mut velocidad : float = 5.0
fn _ready() void {
print(velocidad)
}
OutputParse Error: "@onready" will set the default value after "@editable" takes effect and will override it. (Warning treated as error.)

@tool: código que corre en el editor

Los scripts normalmente solo corren en el juego. @tool, escrito detrás del nombre del módulo, hace que el script corra también dentro del editor. Su uso más conocido es un botón en el inspector, que solo existe en scripts @tool:

main.gro
module Generador @tool
@editable mut semilla : int = 42
@button("Generar") mut generar : Callable = regenerar
fn regenerar() void {
print($"generando con la semilla {semilla}")
}
fn _ready() void {
regenerar()
}
Outputgenerando con la semilla 42
  • @button("Generar") pone un botón con ese texto en el inspector. La variable es un Callable, y su valor es la función que llama el botón: regenerar, sin paréntesis.
  • Sin @tool, @button es un error.

Resumen

AnotaciónDóndeQué hace
@editable, @range, @options…Variables mutMuestran el valor en el inspector
@group, @subgroupAntes de variables editablesLas agrupan en el inspector
@onreadyVariables, watchLes da valor cuando el actor está listo
@persistentStructs, interfaces globalesAñade save y load
@toolDetrás del nombre del móduloEl script corre también en el editor
@buttonUna variable Callable de un script @toolUn botón en el inspector

En los juegos en red verás otras, como @replicated, @owner o @action, que dicen dónde se decide y dónde corre cada cosa.

Hora de practicar

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

¿Cómo se escribe en Grost una variable que se puede cambiar desde el inspector?

En Grost es @editable. @export no existe (es de GDScript), y sin @ no es una anotación.
Hace falta la @ y una palabra que diga que se puede editar.
Reto 2 de 4sin resolver

¿Qué imprime este código?

main.gro
@options("Fácil", "Normal", "Difícil") mut dificultad : int = 2

fn _ready() void {
  print(dificultad)
}
Con @options, el valor es un int: la posición de la opción, empezando en 0. El 2 es "Difícil", pero lo que se imprime es el número.
Mira el tipo de la variable.
Reto 3 de 4sin resolver

Completa el código: las dos variables deben salir en el inspector, dentro del grupo Movimiento.

Salida esperada
13.0
main.gro
("Movimiento")
@editable mut velocidad : float = 5.0
 mut salto : float = 8.0

fn _ready() void {
  print(velocidad + salto)
}
El primer hueco abre un grupo del inspector. El segundo es la anotación que ya lleva la primera variable.
Solución:
main.gro
@group("Movimiento")
@editable mut velocidad : float = 5.0
@editable mut salto : float = 8.0

fn _ready() void {
  print(velocidad + salto)
}
Reto 4 de 4sin resolver

¿Por qué no se juntan @onready y @editable en la misma variable?

@onready asigna su valor después de que se aplique el del inspector, así que lo pisaría. Grost lo trata como un error.
Piensa en el orden: primero se aplica el valor del inspector, y @onready llega después.