Ir al contenido
Descargar
Guía de Gobu

Interfaces de usuario

Menús, HUD, pantallas de pausa: todo lo que el jugador lee o pulsa es una interfaz. En Gobu cada interfaz es un documento .uip, con sus actores y su propio código, igual que una escena o un prefab.

Un .uip es un árbol de actores Control. Lo abres en el editor como cualquier otro documento y su código corre sobre el actor raíz. El panel Palette lista los controles que puedes añadir (tiene un filtro, “Filter Controls”), agrupados por tipo: botones, etiquetas, contenedores, listas, pestañas…

El documento HUD.uip: el árbol de actores a la izquierda, luego la Palette con su filtro Filter Controls y los controles agrupados (Display, Buttons, Containers...), y el HUD en el visor

Los controles más usados:

ControlPara qué
LabelTexto: puntuación, vidas, títulos
ButtonUn botón que se pulsa
TextureRectUna imagen
ProgressBarBarra de vida o de carga

Un contenedor coloca a sus hijos por ti, así la interfaz se adapta al tamaño de la ventana:

Un menú típico es un CenterContainer con un VBoxContainer dentro y los botones en él.

Un menú hecho así: Center (un CenterContainer), Panel (un PanelContainer) y Buttons (un VBoxContainer) con un título y tres botones, centrado en el lienzo

El aspecto de los controles (fuentes, colores, fondos de los botones) sale de un Theme escrito con hojas de estilo: la del proyecto, los estilos propios de cada interfaz y la Class de cada control (lo único que hay en la sección Theme del Inspector). No hay un tema que asignar a un control ni un ajuste del proyecto para él. Cambiar una hoja de estilo cambia todos los controles a la vez, sin tocar cada uno.

Una hoja de estilo escribe un tema con sintaxis CSS. Funcionan como las hojas de estilo de una web: una para todo el proyecto, y cada interfaz con estilos propios encima.

  1. La hoja del proyecto: style/base.gss.

    • Todas las interfaces del juego toman sus estilos. No hay nada que configurar: el archivo es la base por estar ahí (un proyecto nuevo ya lo trae, con las carpetas assets, input, prefabs, scenes y scripts). En el panel Assets su nombre sale en el color de acento. Si lo mueves, lo renombras o lo borras, deja de ser la base, y el editor lo avisa.
    • Las demás hojas van aparte y se traen con @import, al principio, como en la web: @import "../interfaces/styles/PixelUI.gss"; (ruta relativa a la hoja, o res://). Sus reglas van primero, así que las de la hoja que importa ganan un empate.
    • Cada vez que guardas una de ellas, las interfaces se actualizan.
    • No hay ningún ajuste para ella en Project Settings. Un proyecto de antes que tenía su tema en Project Settings → GUI → Theme → Custom (un ajuste que ya no existe) recibe, al abrirse la primera vez, un style/base.gss: una hoja de estilo entra con @import y un recurso Theme se escribe como reglas.

    La hoja del proyecto, style/base.gss, abierta en su propia pestaña: variables en , el tamaño de letra por defecto, los paneles y los botones en cada estado

  2. Los estilos de una interfaz.

    • Cada documento de interfaz (.uip) tiene un panel Styles debajo de su viewport. La pestaña Styles, bajo el lienzo, lo muestra y lo oculta (un clic lo abre y otro lo cierra), así ves cómo cambia la interfaz mientras escribes. Lo que escribes ahí se guarda dentro de la interfaz y solo le da estilo a ella.
    • Las líneas largas se ajustan, y Shift+Alt+F (o Format Styles en el menú del clic derecho) ordena el CSS: una declaración por línea y una línea en blanco entre reglas.
    • Se aplican después de la hoja del proyecto, como una hoja posterior en la web: si la del proyecto dice Button { border-radius: 8px; background: navy } y la de la interfaz dice Button { background: green }, los botones de esa interfaz salen verdes y conservan las esquinas redondeadas.
    • Los cambios se aplican mientras escribes.

    El panel Styles de una interfaz abierto bajo su lienzo, con el menú ya usando sus reglas (Button.Primary, Label.Title...); la pestaña Styles de abajo lo abre y lo cierra

  3. Clases. Una regla como Label.title { ... } da estilo a los controles cuya Class (en la sección Theme del Inspector) es title. La lista ofrece las clases que definen las hojas.

    • Varias clases, como class="card rounded" en la web: márcalas en la lista de Class (el valor son los nombres separados por espacios, Card Rounded). El control toma lo que dice cada una, mezclado como en CSS: .Card pone el fondo y .Rounded las esquinas del mismo estilo. Cuando dos dicen lo mismo, gana la regla que va después en las hojas (el orden de las clases en el control da igual). Una clase que ninguna hoja define se ignora.
    • Para cualquier control, como en la web, escribe la clase sin el tipo: .Card { ... }. Un PanelContainer, un Panel, un Button o un Label con la Class Card la toman todos, así que se escribe una vez en lugar de una por tipo.
    • Da estilo al estilo principal de cada control: el de un panel, el de un botón en todos sus estados (.Card:hover lo cambia al pasar el ratón), el fondo de un ProgressBar (.Card::fill es su barra).
    • Empieza vacía, no desde el aspecto por defecto del control, así que di lo que necesita: fondo, borde, padding…
    • Para cualquier control y para algunos tipos, como en la web: .Card y Button.Card pueden existir a la vez. Un Button con la Class Card toma las dos, mezcladas (Button.Card gana donde dicen lo mismo); cualquier otro control toma solo .Card. Un mismo nombre también puede tener reglas para varios tipos (Label.Title y Button.Title), y la lista de Class lo ofrece a todos los controles.

    El botón Play con la Class Primary en la sección Theme del Inspector, verde por la regla Button.Primary de los estilos de la interfaz

El Inspector no tiene la casilla Theme: el aspecto de un control es la hoja del proyecto, los estilos propios de su interfaz y su Class. La lista de Class ofrece las clases de ambas, y None para ninguna.

Una interfaz hecha antes de esto cuya raíz todavía tiene un Theme (un .gss o un archivo de tema) lo conserva hasta que escribas en su panel Styles, que siempre deja escribir. Lo primero que escribas ocupa el lugar de ese Theme y mantiene el aspecto:

  • un .gss, si el proyecto aún no tiene hoja, pasa a ser la hoja del proyecto;
  • otro .gss copia sus reglas en los estilos de la interfaz;
  • un archivo de tema escribe sus elementos como reglas.

Para borrar los estilos propios de una interfaz, vacía su panel Styles: no queda nada de ellos en el documento.

De overrides a clases. Para una interfaz con estilos a la antigua, pide al asistente de IA que la convierta (style_sheet_convert). Escribe lo que tenía antes la interfaz como estilos propios:

  • Los Theme Overrides de cada nodo pasan a ser una clase (Label.Title { font-color: ...; font-size: 30px; }): el nodo recibe esa Class y se le quitan los overrides. Los nodos con los mismos overrides comparten clase.
  • El Theme (o el .gss) de la raíz pasa a ser reglas de los estilos de la interfaz.

Las reglas son exactas (Button.Play::normal, font-color), así que la interfaz se ve igual, y es una sola acción que se puede deshacer. Lo que CSS no puede expresar (una fuente incrustada, un estilo con color de modulación) se queda como estaba y el asistente lo lista.

:root { --accent: #4a9eff; --panel: #1e2230; }
* { font-family: url("res://fonts/inter.ttf"); font-size: 16px; }
PanelContainer { background: var(--panel); border-radius: 10px; padding: 16px; }
Button {
background: #2a3044;
border: 1px solid #ffffff30;
border-radius: 6px;
padding: 8px 16px;
color: #e8e8e8;
}
Button:hover { background: #343c56; }
Button:pressed { background: var(--accent); color: white; }
Button:disabled { color: #888888; }
Button:focus { border: 2px solid var(--accent); }
Button.Primary { background: var(--accent); }
ProgressBar::fill { background: var(--accent); border-radius: 4px; }
/* Cualquier control con la Class Card */
.Card { background: #2b2e3d; border: 2px solid #ffffff20; border-radius: 8px; padding: 12px; }
  • Selectores:
    • Un tipo de control: Button, Label, PanelContainer…
    • Una clase: Button.Primary. Un control la usa cuando su Class es Primary. .Primary sola es para cualquier control.
    • Estados: :hover, :pressed (o :active), :disabled, :focus, :read-only y :selected, también combinados (:hover:pressed).
    • Partes: ProgressBar::fill, ScrollBar::grabber:hover, TabContainer::tab:selected.
    • Bloques especiales: * lleva la fuente y el tamaño por defecto del tema, y :root, las variables (var(--nombre)).
  • A qué llega una regla: cada elemento toma las reglas que le corresponden, por especificidad y luego por orden, como en CSS.
    • Button { ... } llega a todos los estados, así que en Button:hover basta con lo que cambia.
    • Lo que no escribes conserva el aspecto del tema por defecto: Button { border-radius: 8px } solo redondea las esquinas.
    • :focus se dibuja encima del control (el anillo de foco): solo existe si lo escribes.
  • Propiedades:
    • La caja: background, border (y border-top…), border-radius, padding, box-shadow, expand-margin.
    • El texto: color e icon-color, font-size, font-family (un archivo de fuente con url() o nombres de fuentes del sistema), font-weight (bold, de 100 a 900) y font-style (italic). Una fuente variable usa su propio grosor, una del sistema la negrita y la cursiva de su familia; cualquier otra se dibuja más gruesa e inclinada.
    • Un separador (HSeparator, VSeparator) conserva su línea: border-color (o background) es su color, border-width su grosor y expand-margin cuánto sobresale de sus extremos.
    • El texto de un Label como en la web: text-align, white-space, text-overflow, line-clamp, text-transform, letter-spacing, line-height… (ver Texto).
    • Cualquier otro elemento del control por su nombre: h-separation: 4px, font-outline-color: black, outline-size: 2.
  • Valores: longitudes en px, y colores como #rgb, #rrggbb, #rrggbbaa, rgb(), hsl(), un nombre, o color(srgb r g b / a) con canales de 0 a 1, o más para un color sobreexpuesto (un modulate que aclara: color(srgb 1.5 1.5 1.5)). color-mix(in srgb, a 30%, b) mezcla dos, como en la web; color-mix(in srgb, var(--accent) 50%, transparent) es el acento a media opacidad.

Un estilo puede ser una imagen cortada en nueve partes (esquinas, bordes y centro), como en CSS: las esquinas conservan su tamaño y los bordes y el centro se estiran o se repiten. Es lo habitual para botones y paneles de pixel art.

Button {
--button-image: url("ui/button.png");
--button-pressed-image: url("ui/button_pressed.png");
border-image: var(--button-image) 3 3 4 3 fill; /* dónde cortar, en píxeles de la imagen */
border-width: 9px 9px 12px; /* a qué tamaño se dibujan los bordes: 3x */
image-rendering: pixelated; /* píxeles nítidos */
padding: 2px 8px;
}
Button:pressed { border-image-source: var(--button-pressed-image); }
  • Dónde cortar: border-image: url(...) <corte> fill. El corte son de 1 a 4 números en píxeles de la imagen, sin unidades (o porcentajes). fill dibuja el centro; sin él, el centro queda vacío, como en CSS.
  • A qué tamaño se dibujan los bordes:
    • Por defecto, border-width.
    • Si no, border-image-width: en px, como múltiplo de border-width, o auto para el tamaño del corte.
    • Sin ninguno de los dos, al tamaño de la propia imagen.
    • Si es mayor que el corte, la imagen se dibuja escalada (pixel art dibujado más grande).
  • Repetir: border-image-repeat admite stretch, repeat o round (baldosas enteras).
  • Dibujar fuera del control: border-image-outset (solo sale la imagen).
  • Píxeles nítidos: image-rendering: pixelated (o crisp-edges) dibuja la imagen con filtrado nearest, sin tocar el Texture Filter del control.
  • Estados: Button:pressed { border-image-source: ... } solo cambia la imagen: el corte y los tamaños vienen de Button.
  • Volver a colores: border-image: none hace que el estilo vuelva a ser una caja de color.
  • Variables: se pueden declarar en la propia regla (--button-image en Button), y valen para las reglas de ese control, sus estados y sus variantes.
  • Un color bajo la imagen: como en la web, background-color se pinta debajo de la imagen. Rellena el centro de un borde sin fill y se ve a través de sus píxeles transparentes. border-radius recorta sus esquinas para que no asomen fuera de un borde pixelado redondeado, y un box-shadow también va debajo.
PanelContainer.BorderDark {
border-image: url("ui/dark_border.png") 20% / 1 / 0 stretch; /* hueco: sin fill */
background-color: rgb(194 133 105 / var(--pixel-bg-opacity, 1));
border-width: 5px;
border-radius: 13px; /* las esquinas del color */
image-rendering: pixelated;
padding: 3px;
}

display: none oculta un control desde la hoja de estilo: no se dibuja, no recibe clics ni foco, y su contenedor (cualquiera) no le deja sitio, como visible = false. La diferencia es quién lo decide: visible es la propiedad del propio nodo, la pones en el Inspector o por código y se guarda con la escena; display: none viene de la hoja, así que una regla oculta todos los controles de un tipo o una clase, y no toca su visible. Cambias la clase del control y vuelve a verse con su propio visible. display: flex o block lo muestran. El Inspector lo indica bajo Visible cuando una hoja lo oculta.

.Hidden { display: none; }
Button.IconOnly { display: none; } /* un skin sin esos botones */

Texto: text-align, white-space, text-overflow…

Sección titulada «Texto: text-align, white-space, text-overflow…»

Las propiedades de un Label tienen los nombres de la web, y una hoja de estilo pone las mismas. En el Inspector, un Label muestra primero su texto, luego Align y Vertical como botones, Wrap, Overflow, Line Clamp y Case. Después viene el grupo Typography: fuente, tamaño, color, interlineado, espaciado entre letras y entre palabras, o un recurso Label Settings. Lo demás (justificación, tabulaciones, caracteres visibles, texto de derecha a izquierda) está en Advanced.

Un Label con la Class Title: sus alineaciones como botones, luego Wrap, Overflow, Line Clamp y Case, con las notas Style sheet: text-align: center y text-transform: uppercase que le da la regla Label.Title

CSSEn el InspectorValores
text-alignAlignleft, center, right, justify (start, end)
vertical-alignVerticaltop, middle, bottom
white-space, text-wrapWrapnowrap, normal (corta entre palabras)
overflow-wrap, word-breakWrapbreak-word (también dentro de una palabra larga), break-all (en cualquier sitio)
text-overflow, overflowOverflowclip, ellipsis, un carácter ("~"); overflow: hidden recorta
line-clampLine Clampun número de líneas, o none
text-transformCaseuppercase, lowercase, capitalize, none
letter-spacing, word-spacingLetter / Word Spacingpx (también negativos), normal
line-height(interlineado)px, o una proporción del tamaño de la fuente: 1.5, 150%
tab-sizeTab Sizeun número de espacios
  • Una propiedad en su valor por defecto en el Inspector toma el de la hoja, y el Inspector lo indica debajo (Style sheet: text-align: center). Puesta en el label, gana, como un estilo en línea le gana a una clase.
  • Son de un Label (o de una clase sin tipo, .Title, que un Label tenga). No cambian con el estado: van en Label { } o en la clase, no en :hover.
  • text-shadow: x y [desenfoque] color y -webkit-text-stroke: grosor color dibujan la sombra y el contorno del texto. Valen para cualquier control cuyo texto los tenga: un Button tiene contorno pero no sombra. El desenfoque hace la sombra así de gruesa, no más borrosa.
  • Los puntos suspensivos de Overflow se dibujan siempre que el texto se corta, como en la web; con line-clamp, la última línea que se ve termina con ellos.
Label.Title { text-align: center; text-transform: uppercase; letter-spacing: 2px; }
.Note {
white-space: normal;
overflow-wrap: break-word;
line-clamp: 2;
text-overflow: ellipsis;
line-height: 1.4;
}
Label.Score { text-shadow: 1px 2px 0px #00000080; -webkit-text-stroke: 2px black; }

Las escenas guardadas antes de estos nombres (horizontal_alignment, autowrap_mode, clip_text, text_overrun_behavior, uppercase, max_lines_visible…) se abren con los nuevos y se guardan con ellos. En código, usa los nombres nuevos: label.text_align, label.text_overflow…

background-image: url("...") (o background: url("...")) pone una imagen entera detrás del contenido, llenando la caja como background-size: 100% 100%. background-repeat: repeat la repite a su tamaño (también repeat-x, repeat-y y round, baldosas enteras que encajan). Un background-color queda debajo, y border-radius recorta el color. Un estilo tiene una imagen: gana la última entre background-image y border-image.

background-size: cover cubre la caja (recortada donde no cabe), contain muestra la imagen entera tan grande como cabe, auto mantiene su tamaño, y 100% 100% la llena (lo de por defecto). background-position la coloca: left, center, right, top, bottom, un porcentaje del espacio que sobra, o px (right bottom, 30% 50%, 10px 0). Como en CSS, lo que queda fuera de la caja no se dibuja.

.Hero { background-image: url("ui/sky.png"); background-size: cover; background-position: center top; padding: 24px; }
.Portrait { background-image: url("ui/face.png"); background-size: contain; }
Box.Grass { background: url("ui/grass_tile.png"); background-repeat: repeat; image-rendering: pixelated; }

Como en la web, un estilo puede moverse:

  • transition suaviza un cambio de estado (hover, pressed, disabled…) en vez de saltar: transition: background-color 0.2s ease;. Ponla en la regla del control (o de la clase), así la tienen todos sus estados. Varias van separadas por comas, y también existen las propiedades largas (transition-property, transition-duration, transition-timing-function, transition-delay).
  • @keyframes con animation reproduce una secuencia: animation: pulse 1.5s ease-in-out infinite alternate;. Admite duración, curva, retardo, infinite o un número de veces, reverse / alternate, forwards / backwards / both y paused, y las propiedades largas (animation-name…).
  • Mueven background-color, border-color, border-width, border-radius, box-shadow, el color del texto (Button, Label, LineEdit, las pestañas de un TabBar y los controles basados en ellos), opacity, transform y transform-origin. Lo que cambia la maquetación (padding, tamaños) no. Las transiciones de un TabBar van en su regla TabBar::tab, y cada pestaña se mueve por su cuenta.
  • opacity (de 0 a 1, o un porcentaje) y transform (translate(), rotate(), scale(), respecto al centro del control, o a transform-origin: left top, 30% 50%, 10px 0) también funcionan sin animar, por ejemplo Button:hover { transform: scale(1.05); }. Como en CSS, solo cambian cómo se dibuja el control: sus propiedades, su tamaño, la maquetación y dónde recibe los clics no cambian.
  • Curvas: linear, ease, ease-in, ease-out, ease-in-out, cubic-bezier(), steps().
  • También se reproducen en el visor del editor. Un control solo se redibuja mientras algo se mueve.
@keyframes pulse {
from { background: #202040; }
to { background: #f0c040; }
}
Button.Primary {
background: #3060c0;
border-radius: 6px;
transition: background-color 0.2s ease, border-radius 0.2s;
}
Button.Primary:hover { background: #4078e0; border-radius: 12px; }
.Alert { animation: pulse 1.5s ease-in-out infinite alternate; }
Button.Pop { transition: transform 0.15s ease-out, color 0.15s; }
Button.Pop:hover { transform: scale(1.08) rotate(-2deg); color: #ffe066; }

Un Box coloca a sus hijos como el flexbox de la web. En el Inspector tiene Direction (fila, columna, invertidas), Wrap, Justify Content, Align Items, Align Content y Gap. Su estilo panel es su fondo, y los márgenes de ese estilo son su padding. Los Box dentro de otros Box forman una sola maquetación, así que una columna de filas se dimensiona como en la web.

Un hijo crece con Expand en sus size flags (según su stretch ratio) y se alinea con shrink begin, center o end en el otro eje. Nunca queda más pequeño que su tamaño mínimo. El texto que se ajusta (un Label con autowrap, o un RichTextLabel con autowrap y Fit Content) se comporta como el texto de una página web: tan ancho como quiere hasta el espacio que recibe, nunca más estrecho que su palabra más larga, y tan alto como sus líneas a ese ancho.

Las hojas de estilo maquetan los Box y sus hijos con las propiedades de la web:

  • en un Box (o una clase): flex-direction, flex-wrap, flex-flow, justify-content, align-items, align-content, gap (fila y luego columna), row-gap y column-gap;
  • en cualquier hijo de un Box: flex (1, auto, none, 2 0 100px), flex-grow, flex-shrink, flex-basis, align-self, width, height, min-width, max-width… (px, % o auto), margin (auto centra), aspect-ratio, order (el menor primero; el orden de dibujo sigue siendo el del árbol), y position: absolute con top, right, bottom, left o inset.

Lo que pongas en el Inspector manda. Una propiedad que dejes en su valor por defecto toma el de la hoja, y el Inspector lo dice debajo de ella (“Style sheet: flex-direction: column”); un hijo de un Box muestra la maquetación que le da la hoja en su Container Sizing.

Un Box usado como barra de herramientas: la sección Box del Inspector (Direction, Wrap, Justify Content, Align Items, Align Content, Gap) con las notas de lo que pone la regla Box.Toolbar

Box.Toolbar { gap: 8px; align-items: center; padding: 6px; background: #20242c; }
.Spacer { flex: 1; }
Box.Cards { flex-wrap: wrap; gap: 12px; justify-content: center; }
.Card { width: 120px; aspect-ratio: 3 / 4; }
.Badge { position: absolute; top: -4px; right: -4px; }

Los contenedores clásicos también toman parte:

  • VBoxContainer, HBoxContainer (y BoxContainer): gap es su separación, justify-content su alineación (también space-between, space-around y space-evenly), y align-items coloca a los hijos que llenan el otro eje;
  • HFlowContainer, VFlowContainer: row-gap y column-gap son sus separaciones, y justify-content (inicio, centro o final) su alineación;
  • los hijos de un VBox, un HBox o un flujo toman las mismas propiedades que los de un Box: flex-grow, width, margin, align-self, order… (en un flujo, entonces no se aplica last_wrap_alignment);
  • MarginContainer: padding (y padding-left…) son sus márgenes;
  • en un MarginContainer, PanelContainer, CenterContainer o AspectRatioContainer, el width, height, min-*, max-*, margin y align-self de un hijo lo colocan en el hueco, y el tamaño mínimo del contenedor los cuenta.

También ahí manda el Inspector: una separación puesta como override, o una alineación distinta de Begin, conserva su valor. El Inspector muestra lo que pone la hoja bajo Alignment, y la maquetación de un hijo de una caja bajo su Container Sizing.

VBoxContainer.Menu { gap: 12px; justify-content: center; align-items: center; }
HFlowContainer.Tags { row-gap: 4px; column-gap: 6px; }
.Spacer { flex-grow: 1; }

La maquetación la calcula un motor flexbox propio de Gobu, un port del algoritmo de Yoga comprobado con más de 500 maquetaciones generadas por Chrome. Lo usan todos los contenedores: cajas, flujos, márgenes, paneles, centrado y proporción.

Los errores salen en el Output como archivo:línea:columna: mensaje, por ejemplo Unknown property 'backgroud' for Button. Did you mean 'background'?. El resto de la hoja se aplica igual. Mientras escribes, en un archivo .gss o en el panel Styles de una interfaz:

  • las líneas con un error se marcan y el primero sale bajo el texto;
  • el autocompletado (al escribir, o con Ctrl+Espacio) ofrece lo que cabe ahí:
    • en un selector, los controles, las clases de las hojas, las partes de un control (tras ::) y sus estados (tras :);
    • en una regla, las propiedades de su control (también las suyas propias, como h-separation, y las de maquetación);
    • en un valor, sus palabras clave, las variables (var(--...)) y los nombres de @keyframes;
    • en un keyframe, lo que se puede animar.

Una hoja de estilo con un error: la línea 18 está marcada y el mensaje bajo el texto dice 18:2: Unknown property 'backgroud' for Button.Pause. Did you mean 'background'?

El código de un .uip trae sus controles con use actor:: y responde a sus señales con on:

use actor::Play as play : Button
use actor::Quit as quit : Button
on play.pressed() {
SceneManager.load("level1")
}
on quit.pressed() {
get_tree().quit()
}

Este código va en el propio .uip (necesita sus actores). use y on se explican en Importar con use y Señales.

UiManager muestra un .uip que importas con use ui::. show lo pone en pantalla dentro de su propio CanvasLayer: no se mueve con la cámara ni se mezcla con el orden de dibujo del mundo.

use ui::HUD as hud_ui
use ui::Pause as pause_ui
fn _ready() void {
mut hud : Actor = UiManager.show(hud_ui) # HUD.uip, capa 1
mut pausa : Actor = UiManager.show(pause_ui, 10) # una capa más alta se dibuja encima
UiManager.hide(pausa) # la quita junto con su capa
}

show(ui, layer = 1, parent = null) la añade bajo la escena actual si no le das un padre, y devuelve la raíz de la interfaz. Si quieres meterla dentro de otro actor tú mismo, usa UiManager.instantiate(hud_ui), que solo crea la instancia.

Es el patrón de HUD y menús: la escena (o el GameMode, ver Flujo del juego) muestra la interfaz.

Mostrar valores: watch sobre una interfaz de datos

Sección titulada «Mostrar valores: watch sobre una interfaz de datos»

El HUD no debe preguntar cada frame cuántas monedas hay. Lo habitual es compartir el dato en una interfaz de Grost (un archivo .iface.gro, no confundir con el .uip) y que el HUD lo vigile con watch:

use interface::coins as icoins
use actor::Coins as coins_label : Label
@onready watch icoins.coins(value: int) {
coins_label.text = str(value)
}

Cuando el jugador hace icoins.coins += 1, la etiqueta se actualiza sola. @onready hace que también se ejecute una vez al empezar. Todo esto está en Interfaces y Estado reactivo.