Viniendo de GDScript
Grost viene de GDScript, y mucho te sonará: la API del motor, los tipos, las señales, await.
Pero no es GDScript, y algunas costumbres fallan. Este capítulo las lista, con la forma de
Grost y el capítulo del libro que la explica.
Si nunca has usado GDScript, puedes saltarte este capítulo.
De un vistazo
Sección titulada «De un vistazo»| GDScript | Grost | Capítulo |
|---|---|---|
var x = 1 | mut x := 1 (o x := 1 si nunca cambia) | 1 |
var x: int = 1 | mut x : int = 1 | 1 |
const MAX = 10 | MAX :: 10 | 1 |
x: Variant | no hay tipo dinámico: escribe el tipo; Option[T] si puede faltar | 1 |
var x = null | mut x : Option[int] = none (o mut x : Actor = null) | 1 |
"HP: " + str(hp) | $"HP: {hp}" | 1 |
func f(): | fn f() { } | 3 |
func f() -> int: | fn f() int { } (sin ->) | 3 |
if x: + sangría | if x { } | 4 |
else if / elif | elif | 4 |
match con var nombre | $nombre captura; un nombre suelto compara | 4 |
if x != null: x.f() tras buscarlo | if x := buscar() { x.f() } | 4 |
class X: / clases internas | structs e impl | 5 |
extends, class_name, super | Nada: el código corre en el actor raíz del documento | 6 |
$Player, %Unique, get_node(...) | use actor::Player as player : CharacterBody2D | 6 |
preload(...), load(...) | use prefab::, texture::, audio::… | 6 |
set_meta(...), get_meta(...), obj.set("kind", v) | Un campo pub mut kind : int en el código del prefab, y d.kind = v con mut d := alias.instantiate() | 6 |
self.draw_circle(...) | use actor::Main as root : Spatial2D, y luego root.draw_circle(...) | 6 |
button.pressed.connect(_on_pressed) | on button.pressed() { } | 7 |
hit.emit(n) | emit hit(n) (o hit.emit(n)) | 7 |
set(value): llamado con health = 5 | set health = 5 | 8 |
| un autoload para datos compartidos | una interfaz | 9 |
await en una func normal | async fn | 10 |
llamar a una corrutina sin await | spawn f() | 10 |
call_deferred("f") | later f() | 10 |
@export var x | @editable mut x : T = v | 14 |
código de guardado a mano con FileAccess | @persistent | 12 |
Input.is_action_pressed("jump") | Enhanced Input: foot.jump.is_triggered() | 13 |
archivos .gd | archivos .gro, o el código incrustado del documento | 0 |
El mismo script, en Grost
Sección titulada «El mismo script, en Grost»Aquí tienes una pequeña torreta, escrita como lo harías en GDScript y traducida. Primero sus miembros:
signal fired(shots: int)
MAX_AMMO :: 10@editable mut fire_rate : float = 0.5mut ammo : int = MAX_AMMO { set(value): field = clamp(value, 0, MAX_AMMO) get(): return field}mut target : Actor = nullsignales igual.- La constante usa
::; la variable exportada usa@editable mut. - La propiedad con setter lleva su
set/geten un bloque{ }justo después del valor inicial, yfieldes el valor guardado. - Una variable que puede empezar vacía lleva su tipo escrito (
: Actor = null).
Después sus funciones:
fn can_fire() bool { return ammo > 0 and target != null}
fn fire() void { if not can_fire() { return } set ammo = ammo - 1 emit fired(MAX_AMMO - ammo) print($"Ammo: {ammo}/{MAX_AMMO}")}
fn describe(state: int) String { mut text := "unknown" match state { 0: { text = "idle" } 1: { text = "aiming" } } return text}- El tipo de retorno va justo después de los parámetros, sin
->. set ammo = ...ejecuta el setter. Sinset, la asignación no pasa por él.emit fired(...)emite la señal;$"..."mete valores en el texto.- Las ramas de
matchvan entre llaves, una por valor.
Y la parte que espera:
async fn burst(shots: int) void { defer { print("burst over") } for _i : int in range(shots) { fire() await sleep(fire_rate) }}
fn _ready() void { spawn burst(3) later fire()}- Una función con
awaites unaasync fn. spawnla arranca sin esperar.defer { }corre cuando la función termina, termine como termine.later fire()es elcall_deferredde GDScript.
Las diferencias, una a una
Sección titulada «Las diferencias, una a una»Sin clases
Sección titulada «Sin clases»No hay class, extends, class_name ni super. El parser los rechaza, y para casi todos su
error dice qué usar en su lugar.
Cada documento (.scene, .prefab, .uip) tiene su propio código, y ese código corre en su
nodo raíz. module Nombre en la primera línea le pone nombre al script, y el nodo recibe ese
nombre como etiqueta.
Para reutilizar comportamiento no heredas: haces un prefab y lo instancias. Para datos con
funciones, usa un struct con impl (capítulo 5). Para datos compartidos
entre documentos, una interfaz (capítulo 9).
Declaraciones
Sección titulada «Declaraciones»var, let, func y const no existen. En GDScript escribirías:
const MAX_VIDAS = 3var vidas = 3
func curar(cantidad: int) -> int: return vidas + cantidadEn Grost:
MAX_VIDAS :: 3mut vidas : int = 3
fn curar(cantidad: int) int { return vidas + cantidad}
fn _ready() void { print(curar(2))}mut x := 1: una variable.x := 1, sinmut: no se puede reasignar (asignarla es un error).X :: 10: una constante.fn f(a: int) int { }: una función. El tipo de retorno va después de los parámetros, sin->.- No hay
Variant: cada variable y parámetro tiene un tipo. Dentro de una función,mut x = 5también vale: tomaintde su valor.mut x := nullno funciona: escribe el tipo. - Un valor que puede faltar es un
Option[T](some(v)/none), que se comprueba antes de usarlo:x ?? por_defecto,if x is some(v),match. - Un valor que el motor da sin tipo conocido (JSON, un elemento de un Array sin tipo,
dict["clave"]) no se usa como uno con tipo directamente:(valor as int) ?? 0(capítulo 1). pubhace un miembro visible para otros scripts; añademutpara que puedan escribirlo.
Bloques con llaves
Sección titulada «Bloques con llaves»Los bloques siempre van entre { }, nunca : con sangría. El ; es opcional. Escribe elif
(else if también se acepta, pero elif es la forma canónica).
Actores y recursos con use
Sección titulada «Actores y recursos con use»No hay $Nodo, %Unico, get_node(), preload() ni load(). Un actor del documento y los
archivos del proyecto se importan arriba con use:
use actor::Player as player : CharacterBody2Duse prefab::Projectile as bulletuse audio::jump as jump_sndEl tipo después de : se comprueba contra el actor real, y un archivo que no existe es un
error al escribirlo, no cuando el juego llega a esa línea.
self es tu código, no el actor: no tiene ninguno de los métodos de Spatial2D o Control.
Para los métodos del actor raíz, impórtalo por su nombre: use actor::Main as root : Spatial2D.
Los setters necesitan set
Sección titulada «Los setters necesitan set»En GDScript, vida = 5 ejecuta el setter:
var vida := 100: set(valor): vida = clamp(valor, 0, 100)En Grost solo lo hace set vida = 5; una asignación normal escribe el valor directamente:
mut vida : int = 100 { set(valor): field = clamp(valor, 0, 100)}
fn _ready() void { vida = 150 # sin setter: vida vale 150 set vida = 150 # corre el setter: vida vale 100 print(vida)}Lo mismo con las variables live: sus observadores reciben el aviso con set.
defer significa otra cosa
Sección titulada «defer significa otra cosa»GDScript no tiene defer, pero el código Grost antiguo usaba defer f() para “llamar
después”. Ahora:
later f(): llama afal final del frame (call_deferred).defer { ... }: ejecuta un bloque al salir del bloque actual.
fn _ready() void { later decir("final del frame") defer { print("salgo de _ready") } print("dentro de _ready")}
fn decir(texto: String) void { print(texto)}Imprime dentro de _ready, luego salgo de _ready y luego final del frame.
Corrutinas
Sección titulada «Corrutinas»En GDScript, cualquier func puede usar await, y llamarla sin await la arranca sin
esperar:
func cuenta_atras(): for i in range(3, 0, -1): print(i) await get_tree().create_timer(0.1).timeout
func _ready(): cuenta_atras()En Grost:
- Una función que usa
awaittiene que serasync fn. - Llamar a una
async fnsinawaites un error: para lanzarla sin esperar, usaspawn f(). Recibes una tarea que puedes cancelar concancel().
async fn cuenta_atras() void { for i : int in range(3, 0, -1) { print(i) await sleep(0.1) }}
fn _ready() void { spawn cuenta_atras()}Texto con valores
Sección titulada «Texto con valores»$"HP: {hp}/{max_hp}" sustituye a "HP: " + str(hp) y a "HP: %d" % hp (que también
funciona). Una cadena normal no interpola: "HP: {hp}" imprime las llaves tal cual.
Los structs no son Variants
Sección titulada «Los structs no son Variants»Un struct es un valor simple, no un Variant. No puedes meterlo en un Array o un
Dictionary sin tipo, ni pasarlo a una función del motor que acepta cualquier valor. En su
lugar:
- guarda los structs en una colección con tipo:
[]Punto,Dictionary[String, Punto]; - o pasa sus campos;
- o convierte el struct en un diccionario con
to_dict().
print(p) sí funciona: muestra los campos, como en Punto(x: 1).
Métodos con nombres de Object
Sección titulada «Métodos con nombres de Object»obj.call(&"jump") solo hace falta cuando el nombre del método choca con uno de Object (get,
is_connected…). Si no, llámalo directamente: obj.jump().
Dónde va cada cosa
Sección titulada «Dónde va cada cosa»| En GDScript harías… | En Gobu |
|---|---|
| Poner la lógica del jugador en el script del nivel | El jugador es un prefab con su propio código; la escena lo instancia |
Añadir Labels del HUD a la escena | Un .uip con su propio código |
| Usar un autoload para la puntuación | Una interfaz global |
Escribir partidas con FileAccess | @persistent |
Usar Input.is_action_pressed | Acciones y contextos de Enhanced Input |
| Usar muchos actores con el mismo script para las balas | Sistemas ECS (capítulo 11) |