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.
El documento .uip
Sección titulada «El documento .uip»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…

Los controles más usados:
| Control | Para qué |
|---|---|
| Label | Texto: puntuación, vidas, títulos |
| Button | Un botón que se pulsa |
| TextureRect | Una imagen |
| ProgressBar | Barra de vida o de carga |
Contenedores
Sección titulada «Contenedores»Un contenedor coloca a sus hijos por ti, así la interfaz se adapta al tamaño de la ventana:
- VBoxContainer / HBoxContainer: en columna o en fila.
- GridContainer: en rejilla.
- CenterContainer: centra a su hijo.
- MarginContainer: añade márgenes.
- PanelContainer: un fondo detrás de su contenido.
- Box: un
divde la web condisplay: flex. Coloca a sus hijos en fila o en columna, en varias líneas o no, con huecos y alineación, y dibuja un fondo. Ver Maquetación.
Un menú típico es un CenterContainer con un VBoxContainer dentro y los botones en él.

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.
Hojas de estilo (.gss)
Sección titulada «Hojas de estilo (.gss)»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.
-
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,scenesyscripts). 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, ores://). 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@importy un recurso Theme se escribe como reglas.

- 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
-
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 diceButton { background: green }, los botones de esa interfaz salen verdes y conservan las esquinas redondeadas. - Los cambios se aplican mientras escribes.

- Cada documento de interfaz (
-
Clases. Una regla como
Label.title { ... }da estilo a los controles cuya Class (en la sección Theme del Inspector) estitle. 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:.Cardpone el fondo y.Roundedlas 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 ClassCardla 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:hoverlo cambia al pasar el ratón), el fondo de un ProgressBar (.Card::filles 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:
.CardyButton.Cardpueden existir a la vez. Un Button con la ClassCardtoma las dos, mezcladas (Button.Cardgana donde dicen lo mismo); cualquier otro control toma solo.Card. Un mismo nombre también puede tener reglas para varios tipos (Label.TitleyButton.Title), y la lista de Class lo ofrece a todos los controles.

- Varias clases, como
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
.gsscopia 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 esPrimary..Primarysola es para cualquier control. - Estados:
:hover,:pressed(o:active),:disabled,:focus,:read-onlyy: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)).
- Un tipo de control:
- 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 enButton:hoverbasta con lo que cambia.- Lo que no escribes conserva el aspecto del tema por defecto:
Button { border-radius: 8px }solo redondea las esquinas. :focusse dibuja encima del control (el anillo de foco): solo existe si lo escribes.
- Propiedades:
- La caja:
background,border(yborder-top…),border-radius,padding,box-shadow,expand-margin. - El texto:
coloreicon-color,font-size,font-family(un archivo de fuente conurl()o nombres de fuentes del sistema),font-weight(bold, de100a900) yfont-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(obackground) es su color,border-widthsu grosor yexpand-margincuá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.
- La caja:
- Valores: longitudes en
px, y colores como#rgb,#rrggbb,#rrggbbaa,rgb(),hsl(), un nombre, ocolor(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.
Imágenes: border-image
Sección titulada «Imágenes: border-image»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).filldibuja 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: enpx, como múltiplo deborder-width, oautopara 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).
- Por defecto,
- Repetir:
border-image-repeatadmitestretch,repeatoround(baldosas enteras). - Dibujar fuera del control:
border-image-outset(solo sale la imagen). - Píxeles nítidos:
image-rendering: pixelated(ocrisp-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 deButton. - Volver a colores:
border-image: nonehace que el estilo vuelva a ser una caja de color. - Variables: se pueden declarar en la propia regla (
--button-imageenButton), y valen para las reglas de ese control, sus estados y sus variantes. - Un color bajo la imagen: como en la web,
background-colorse pinta debajo de la imagen. Rellena el centro de un borde sinfilly se ve a través de sus píxeles transparentes.border-radiusrecorta sus esquinas para que no asomen fuera de un borde pixelado redondeado, y unbox-shadowtambié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;}Ocultar: display: none
Sección titulada «Ocultar: display: none»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.

| CSS | En el Inspector | Valores |
|---|---|---|
text-align | Align | left, center, right, justify (start, end) |
vertical-align | Vertical | top, middle, bottom |
white-space, text-wrap | Wrap | nowrap, normal (corta entre palabras) |
overflow-wrap, word-break | Wrap | break-word (también dentro de una palabra larga), break-all (en cualquier sitio) |
text-overflow, overflow | Overflow | clip, ellipsis, un carácter ("~"); overflow: hidden recorta |
line-clamp | Line Clamp | un número de líneas, o none |
text-transform | Case | uppercase, lowercase, capitalize, none |
letter-spacing, word-spacing | Letter / Word Spacing | px (también negativos), normal |
line-height | (interlineado) | px, o una proporción del tamaño de la fuente: 1.5, 150% |
tab-size | Tab Size | un 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 enLabel { }o en la clase, no en:hover. text-shadow: x y [desenfoque] colory-webkit-text-stroke: grosor colordibujan 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…
Imágenes de fondo: background-image
Sección titulada «Imágenes de fondo: background-image»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; }Transiciones y animaciones
Sección titulada «Transiciones y animaciones»Como en la web, un estilo puede moverse:
transitionsuaviza 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).@keyframesconanimationreproduce una secuencia:animation: pulse 1.5s ease-in-out infinite alternate;. Admite duración, curva, retardo,infiniteo un número de veces,reverse/alternate,forwards/backwards/bothypaused, y las propiedades largas (animation-name…).- Mueven
background-color,border-color,border-width,border-radius,box-shadow, elcolordel texto (Button, Label, LineEdit, las pestañas de un TabBar y los controles basados en ellos),opacity,transformytransform-origin. Lo que cambia la maquetación (padding, tamaños) no. Las transiciones de un TabBar van en su reglaTabBar::tab, y cada pestaña se mueve por su cuenta. opacity(de 0 a 1, o un porcentaje) ytransform(translate(),rotate(),scale(), respecto al centro del control, o atransform-origin: left top,30% 50%,10px 0) también funcionan sin animar, por ejemploButton: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; }Maquetación: Box (flexbox)
Sección titulada «Maquetación: Box (flexbox)»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-gapycolumn-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,%oauto),margin(autocentra),aspect-ratio,order(el menor primero; el orden de dibujo sigue siendo el del árbol), yposition: absolutecontop,right,bottom,leftoinset.
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.

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(yBoxContainer):gapes su separación,justify-contentsu alineación (tambiénspace-between,space-aroundyspace-evenly), yalign-itemscoloca a los hijos que llenan el otro eje;HFlowContainer,VFlowContainer:row-gapycolumn-gapson sus separaciones, yjustify-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 aplicalast_wrap_alignment); MarginContainer:padding(ypadding-left…) son sus márgenes;- en un
MarginContainer,PanelContainer,CenterContaineroAspectRatioContainer, elwidth,height,min-*,max-*,marginyalign-selfde 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.
- en un selector, los controles, las clases de las hojas, las partes de un control (tras

Botones: on button.pressed()
Sección titulada «Botones: on button.pressed()»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 : Buttonuse 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.
Mostrar una interfaz: UiManager
Sección titulada «Mostrar una interfaz: UiManager»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_uiuse 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 icoinsuse 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.