Ir al contenido
Descargar
El libro de Grost

Importar con use

Un script necesita llegar a lo que tiene alrededor: los actores de su documento, los prefabs que crea, los sonidos que reproduce. En Grost todo eso entra por una sola puerta: use.

Una sola puerta tiene una ventaja: cada script lista al principio todo lo que necesita, así ves sus dependencias de un vistazo en vez de encontrar rutas repartidas por el código.

Los ejemplos de este capítulo necesitan una escena con esos actores y un proyecto con esos archivos, así que son bloques cortos y no archivos de ejemplo completos.

Tu código mueve al jugador, reproduce una animación, mira dónde está un enemigo. Antes tiene que llegar a esos actores:

module Player
use actor::Player as player : CharacterBody2D
use actor::Character with AnimationPlayer as animation : AnimationPlayer
use actor::leg-left as leg_left : Spatial2D

La forma es siempre:

use <namespace>::<nombre> [with <HijoÚnico>] [as <alias>] [: <TipoDeNodo>]

Las partes entre [ ] son opcionales:

ParteQué hace
actor::PlayerEl namespace (qué tipo de cosa) y el nombre del actor
with XLlega al hijo con nombre único X dentro de la subescena de ese actor
as playerEl alias: el nombre que usas en el código
: CharacterBody2DEl tipo del alias
  • Las líneas use van al principio del script, justo después de module.
  • Sin as, el alias es el propio nombre. Los nombres con - necesitan alias.
  • : Tipo le da tipo al alias, así tienes autocompletado y comprobación de tipos. Solo existe en actor:: y tiene que coincidir con el actor real: un tipo equivocado se rechaza.
  • Los alias no se pueden repetir ni chocar con otros miembros.

La raíz es el actor de arriba del documento, el que contiene a todos los demás. Se importa como cualquier otro actor, por su propio nombre:

module Main
use actor::Main as root : Spatial2D

Ahora funcionan root.draw_circle(...) y on root.draw() { }.

self es otra cosa: es el código mismo, y no tiene ninguno de los métodos de Spatial2D ni de Control. self as Spatial2D no convierte; usa el alias de la raíz.

Los demás namespaces traen archivos del proyecto: el prefab de una bala, el sonido de un salto, la imagen de un icono.

Se buscan por nombre de archivo, no por ruta y sin extensión: use audio::jump encuentra res://.../jump.wav. Así puedes mover un archivo a otra carpeta sin cambiar el código.

NamespaceImporta
prefab::un .prefab
ui::un .uip
scene::un .scene
audio::un .wav, .ogg, .mp3 o .flac
texture::un .png, .jpg, .jpeg, .webp o .svg
model::, material::, mesh::, shader::, font::, resource::otros recursos
input::un contexto de entrada (capítulo 13)
interface::una interfaz de Grost (capítulo 9)

Un prefab es una pieza que construyes una vez y creas tantas veces como quieras, como una flecha:

use actor::Player as player : CharacterBody2D
use prefab::Arrow as arrow
fn shoot() void {
mut a := arrow.instantiate()
a.position = player.position
GetWorld.add_child(a)
}

arrow.instantiate() crea una copia nueva, con el tipo de la clase raíz del prefab.

Los sonidos y las imágenes entran igual:

use audio::jump as jump_snd
use texture::icon as icon_tex
fn play_jump() void {
AudioManager.play_sound(jump_snd) # dispara y olvida
AudioManager.play_sound_at_location(jump_snd, Vector2(10, 20))
}

A algunas cosas se llega a través de managers globales: objetos del motor que siempre están ahí, como SceneManager o GetWorld. También buscan por nombre de archivo.

SceneManager cambia de nivel. Eso se hace como respuesta a algo (el jugador llega a la salida), así que aquí va dentro de funciones:

fn next_level() void {
SceneManager.load("level2") # cambia a level2.scene
}
fn try_again() void {
SceneManager.restart() # recarga la escena actual
}

GetWorld crea y encuentra entidades, los actores que aparecen durante el juego:

use prefab::slime as slime_prefab # sin el use, spawn("slime") es error de compilación
fn _ready() void {
mut slime : Spatial2D = GetWorld.spawn("slime") # instancia de slime.prefab, aún fuera del árbol
slime.position = Vector2(0, 1)
GetWorld.add_child(slime) # la añade a la escena actual
print(GetWorld.count("slime")) # 1
GetWorld.despawn(slime) # ocultar + liberar
}

Con use prefab::slime as slime_prefab, también funciona slime_prefab.instantiate().

Recuerda de la introducción que module <Nombre> también es una etiqueta, un rótulo para encontrar actores. GetWorld encuentra actores por etiqueta, sin distinguir mayúsculas de minúsculas (module Player se encuentra como "player"):

@onready target : Actor = await GetWorld.Spawned("player") # espera a que exista
fn _ready() void {
mut all : Array = GetWorld.SpawnedAll("enemy") # lista inmediata
}

Spawned hay que esperarlo con await; el capítulo 10 lo explica.

UiManager pone interfaces en pantalla. AudioManager reproduce sonidos, como viste arriba con jump_snd:

use ui::scoreboard as scoreboard_ui # el use hace que el export incluya scoreboard.uip
fn _ready() void {
mut board : Actor = UiManager.show(scoreboard_ui) # en pantalla, en su propio CanvasLayer
}

GameMode arranca una partida con jugador y HUD (la interfaz que muestra vidas, puntos y demás). Declara también con use su prefab y su interfaz:

use prefab::hero as hero_prefab
use ui::scoreboard as scoreboard_ui
fn _ready() void {
GameMode.set_player_prefab("hero")
GameMode.set_hud_prefab("scoreboard")
mut p : Actor = GameMode.start() # crea jugador + HUD y devuelve el jugador
}