Ir al contenido
Descargar
El libro de Grost

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.

GDScriptGrostCapítulo
var x = 1mut x := 1 (o x := 1 si nunca cambia)1
var x: int = 1mut x : int = 11
const MAX = 10MAX :: 101
x: Variantno hay tipo dinámico: escribe el tipo; Option[T] si puede faltar1
var x = nullmut 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íaif x { }4
else if / elifelif4
match con var nombre$nombre captura; un nombre suelto compara4
if x != null: x.f() tras buscarloif x := buscar() { x.f() }4
class X: / clases internasstructs e impl5
extends, class_name, superNada: el código corre en el actor raíz del documento6
$Player, %Unique, get_node(...)use actor::Player as player : CharacterBody2D6
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 = 5set health = 58
un autoload para datos compartidosuna interfaz9
await en una func normalasync fn10
llamar a una corrutina sin awaitspawn f()10
call_deferred("f")later f()10
@export var x@editable mut x : T = v14
código de guardado a mano con FileAccess@persistent12
Input.is_action_pressed("jump")Enhanced Input: foot.jump.is_triggered()13
archivos .gdarchivos .gro, o el código incrustado del documento0

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.5
mut ammo : int = MAX_AMMO {
set(value): field = clamp(value, 0, MAX_AMMO)
get(): return field
}
mut target : Actor = null
  • signal es igual.
  • La constante usa ::; la variable exportada usa @editable mut.
  • La propiedad con setter lleva su set/get en un bloque { } justo después del valor inicial, y field es 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. Sin set, la asignación no pasa por él.
  • emit fired(...) emite la señal; $"..." mete valores en el texto.
  • Las ramas de match van 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 await es una async fn.
  • spawn la arranca sin esperar.
  • defer { } corre cuando la función termina, termine como termine.
  • later fire() es el call_deferred de GDScript.

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).

var, let, func y const no existen. En GDScript escribirías:

const MAX_VIDAS = 3
var vidas = 3
func curar(cantidad: int) -> int:
return vidas + cantidad

En Grost:

MAX_VIDAS :: 3
mut vidas : int = 3
fn curar(cantidad: int) int {
return vidas + cantidad
}
fn _ready() void {
print(curar(2))
}
  • mut x := 1: una variable. x := 1, sin mut: 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 = 5 también vale: toma int de su valor. mut x := null no 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).
  • pub hace un miembro visible para otros scripts; añade mut para que puedan escribirlo.

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).

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 : CharacterBody2D
use prefab::Projectile as bullet
use audio::jump as jump_snd

El 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.

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.

GDScript no tiene defer, pero el código Grost antiguo usaba defer f() para “llamar después”. Ahora:

  • later f(): llama a f al 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.

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 await tiene que ser async fn.
  • Llamar a una async fn sin await es un error: para lanzarla sin esperar, usa spawn f(). Recibes una tarea que puedes cancelar con cancel().
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()
}

$"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.

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).

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().

En GDScript harías…En Gobu
Poner la lógica del jugador en el script del nivelEl jugador es un prefab con su propio código; la escena lo instancia
Añadir Labels del HUD a la escenaUn .uip con su propio código
Usar un autoload para la puntuaciónUna interfaz global
Escribir partidas con FileAccess@persistent
Usar Input.is_action_pressedAcciones y contextos de Enhanced Input
Usar muchos actores con el mismo script para las balasSistemas ECS (capítulo 11)