Juegos en red
Gobu convierte un juego en uno en red sin código de red. Marcas qué es online y Gobu conecta los juegos, crea un personaje por jugador, mantiene el mundo de todos igual y guarda el progreso de cada jugador en el servidor. El mismo juego sigue funcionando sin red, sin cambiar nada.
Las reglas son las de Unreal Engine: lo replicado lo decide el servidor; los jugadores lo piden.
Marcar qué es online
Sección titulada «Marcar qué es online»Selecciona la raíz de un prefab y cambia Inspector > Online > Mode:
| Modo | Para | Qué pasa |
|---|---|---|
| Player | El personaje | Cada jugador que entra tiene el suyo. Lo mueve su jugador; los demás lo ven moverse y animarse. |
| Shared | Un objeto del mundo (un árbol, una puerta, un cofre, algo tirado en el suelo) | Lo ejecuta el servidor; todos ven lo mismo. |
| Shared + Local Code | Un objeto del mundo que además dibuja algo para cada jugador | Como Shared, y su código corre también en la copia de cada jugador (un anillo que se ilumina al acercarte, un panel de progreso). Lo que ese código cambie del mundo no cuenta. |
| Off | Todo lo demás | Cada juego tiene el suyo. |

Lo que se mueve, cómo se ve y con qué se choca viaja solo: posición, rotación y escala, visibilidad, color, orden de dibujo, frames y volteo de los sprites, la animación que se reproduce, la posición de cada parte del objeto y sus colisiones (si cada forma está activa y sus medidas: el radio más pequeño de un tocón). Un objeto del mundo que cambia su forma de colisión en el servidor no necesita código para que los jugadores choquen con la nueva.
En la copia de cada jugador, Online ejecuta él mismo el código local, una vez por frame.
set_process(false) también lo duerme ahí: un árbol sin nadie cerca no tiene nada que hacer.
set_process(true) lo despierta, y sigue corriendo una vez por frame. Un color que decide cada
jugador va en lo que dibuja el código (draw_*), no en modulate ni en self_modulate: esos los
envía el servidor, como el resto del aspecto.
El personaje también puede ser el Player de Project Settings > Application > Game Mode (con Online > Mode: Player en su prefab) en vez de uno colocado en el nivel: cada nivel lo crea y cada jugador que entra recibe uno.
Dónde empieza el personaje de cada jugador: pon actores PlayerStart en el nivel. El personaje del anfitrión empieza en el primero y los jugadores que entran en los siguientes, por turnos si hay más jugadores que PlayerStarts; en un servidor dedicado el primer jugador que entra ocupa el primero. Sin PlayerStarts, aparecen junto al personaje colocado. Ver PlayerStart.
Estado y acciones
Sección titulada «Estado y acciones»| Anotación | En | Hace | En Unreal |
|---|---|---|---|
@replicated | Una variable | La decide el servidor; la reciben todos | UPROPERTY(Replicated) |
@owner | Una variable | La decide el servidor; solo la recibe el dueño del objeto | COND_OwnerOnly |
@action | Una función | Se ejecuta en el servidor. En un personaje solo la pide su jugador; en un objeto del mundo, cualquiera | RPC Server |
@owner | Una función | Se ejecuta en el juego del dueño del objeto; la pide el servidor | RPC Client |
@predicted | Una @action | Se ejecuta también al momento en el juego que la pide; los valores del servidor sustituyen la predicción | Predicción en el cliente |
@everyone | Una función | Se ejecuta en todos los juegos: al momento en el que la llama, después en los demás | RPC NetMulticast |
@persistent | Una variable @replicated/@owner | El servidor la guarda para ese jugador entre partidas | Persistencia de Verse |
Se llaman y se escriben como siempre; la llamada viaja a donde se ejecuta:
# Arbol.prefab (Mode: Shared)@replicated pub mut golpes : int = 0@replicated pub live cortado : bool = false
# En cada jugador, cuando llega el valor: la colisión del tocón.watch cortado(valor: bool) { print("tocón: ", valor) # p. ej. ajustar la colisión al tocón}
@action pub fn talar() void { golpes += 1 if golpes >= 3 { set cortado = true }}# En el nivel: cualquier jugador la llama, se ejecuta en el servidor, todos ven el árbol cortado.arbol.talar()Lo que un jugador escriba en una variable replicada no cuenta: vuelve al valor del servidor (con
un aviso). Para cambiarla, el jugador la pide con una @action.
Quién lo tocó
Sección titulada «Quién lo tocó»Online.player_of(nodo) da el personaje (Mode Player) al que pertenece un actor, y el nombre de
un prefab es un tipo. Una madera en el suelo, que corre en el servidor, se le da al jugador que la
toca:
# Madera.prefab (Mode: Shared)use actor::Madera as root : Sprite2Duse actor::AreaRecogida as area : Area2D
mut quien : Lenador = null
on area.body_entered(cuerpo: Spatial2D) { quien = Online.player_of(cuerpo) as Lenador}
fn _physics_process(_delta: float) void { if quien != null and quien.madera < 64 { quien.madera += 1 root.queue_free() # Desaparece para todos. }}Botín para un jugador: reserve
Sección titulada «Botín para un jugador: reserve»Un objeto del mundo se puede guardar para un jugador (o un equipo) durante un tiempo: la madera que suelta
un árbol es del que lo cortó. Todos ven caer el árbol; con Online.HIDDEN solo ese jugador ve la madera.
# Arbol.prefab (Mode: Shared)use prefab::madera as madera_prefab
@action pub fn talar(quien: Lenador) void { golpes += 1 if golpes >= 3 { set cortado = true mut madera := madera_prefab.instantiate() madera.position = position GetWorld.add_child(madera) Online.reserve(madera, quien, 30.0) # todos la ven, solo quien la coge; a los 30 s, de cualquiera }}
# Madera.prefab (Mode: Shared), al tocarlaon area.body_entered(cuerpo: Spatial2D) { quien := Online.player_of(cuerpo) as Lenador if quien != null and Online.can_take(root, quien) { quien.madera += 1 root.queue_free() }}-
Online.reserve(nodo, jugadores, segundos, flags):jugadoreses un personaje, un id de jugador o unArrayde ellos (un equipo);segundos = 0la guarda hastaOnline.release(nodo)o hasta que se vayan todos. -
Flags, juntos con
|:Online.HIDDEN: solo la reciben sus jugadores. Los juegos de los demás no la tienen (un juego modificado tampoco puede mostrarla), sus@actionsobre ella se rechazan y, en el servidor, sus áreas no detectan a sus personajes: la madera que no ven no la recogen, sin código. En un anfitrión que juega, también se oculta en su pantalla. Cuando la reserva termina, los demás la reciben, como cuando algo se acerca.Online.DESTROY_AFTER: cuando se acaba su tiempo (o se van sus jugadores), se quita en vez de pasar a ser de cualquiera.Online.PAUSE_WHEN_FAR: su tiempo se para mientras ninguno de sus jugadores está cerca (Interest Distance): el botín que dejaste te espera.
-
Guardada sin
HIDDEN, todos la ven y la tocan: compruebaOnline.can_take(nodo, quien)donde se recoge. -
on Online.reservation_ended(nodo: Actor, motivo: int)(en el servidor):Online.TIMEOUT,Online.OWNER_LEFT,Online.RELEASEDoOnline.LIMIT, antes de que pase a ser de cualquiera o se quite; llamar aOnline.reserve()ahí la guarda para otro (el siguiente del equipo, por ejemplo). -
Online.get_reserved_for(nodo)yOnline.get_reservation_time_left(nodo)dicen cómo está guardada. -
Un jugador que se va deja de ser uno de sus jugadores (no con
KEEP, abajo). SinKEEPla reserva dura la partida, y un anfitrión nuevo (migración) empieza sin ninguna.
Botín que sigue ahí otro día: KEEP
Sección titulada «Botín que sigue ahí otro día: KEEP»Con Online.KEEP el objeto y su reserva se guardan con el mundo: el botín que dejaste en una isla sigue
ahí, y sigue siendo tuyo, cuando vuelves otro día.
Online.reserve(madera, quien, 0.0, Online.HIDDEN | Online.KEEP) # solo quien la ve, en cada partidaOnline.reserve(cofre, quien, 86400.0, Online.KEEP | Online.REAL_TIME) # desaparece a las 24 h, juegue o no- Un objeto creado durante la partida (la madera que soltó el árbol) también se guarda, y el servidor lo
crea otra vez desde su prefab al arrancar: donde estaba, con su estado y sus valores
@persistent. - Sus jugadores son quienes son (la clave de sus datos guardados, su cuenta si inician sesión): irse no la termina, y vuelve a ser suya cuando vuelven.
- Su tiempo solo corre mientras juega alguno de sus jugadores; con
Online.REAL_TIMEcorre siempre, también con el servidor apagado. - Cuando la reserva termina sigue guardada, de cualquiera, hasta que alguien la coge o se quita.
- Project Settings > Online > Persistence > Max Kept Objects per Player y Max Kept Objects (el mundo
entero) lo limitan;
0, por defecto, es sin límite. La sección Persistence se ve con Advanced Settings activado (el interruptor que está arriba en la barra lateral de Project Settings). Al pasarse, la más vieja deja de guardarse:reservation_endedconOnline.LIMIT(se quita conDESTROY_AFTER, si no pasa a ser de cualquiera) y ya no se guarda.Online.get_kept_objects(quien)(oget_kept_objects(), todas) te deja elegir a ti qué se va. Sin límite, el servidor avisa una vez cuando hay muchas. KEEPes para objetos creados durante la partida: uno colocado en el nivel ya guarda sus valores@persistent. Necesita el almacén de datos guardados: no en un servidor web.
Sin código: Reserve For en el prefab
Sección titulada «Sin código: Reserve For en el prefab»Lo mismo, puesto en el Inspector de la raíz del prefab, en Online (con Mode: Shared):
- Reserve For: Who Asked: una instancia creada en el servidor durante la
@actionde un jugador (eltalar()del árbol que suelta la madera) se guarda para ese jugador. Sin llamar aOnline.reserve(). Who Asked’s Team: para el equipo de ese jugador (abajo), o solo para él si no tiene. - Reserve Seconds y Reserve Flags (Hidden, Destroy After, Pause When Far, Keep, Real Time): como
los
segundosyflagsdeOnline.reserve().

# Arbol.prefab (Mode: Shared). Madera.prefab: Reserve For: Who Asked, 30 s, Hidden@action pub fn talar() void { golpes += 1 if golpes >= 3 { mut madera := madera_prefab.instantiate() madera.position = position GetWorld.add_child(madera) # guardada para el jugador que taló }}- Creada fuera de una
@action(el código del propio mundo, un temporizador), es de cualquiera. - En un anfitrión que juega, las acciones que pide él mismo son de su jugador.
- Instánciala en la acción, antes de cualquier
await(después de uno ya no se sabe quién la pidió); añadirla después vale (later GetWorld.add_child(madera)). Online.reserve()sobre ella después sustituye la reserva del prefab (otro jugador, otro tiempo).
Equipos
Sección titulada «Equipos»El servidor pone a cada jugador en un equipo, y lo que se guarda para un equipo es de quien esté en él en cada momento:
# Reglas.prefab (en el servidor)on Online.player_joined(id: int) { Online.set_team(id, "rojo" if Online.get_team_players("rojo").size() <= Online.get_team_players("azul").size() else "azul")}
Online.reserve(cofre, "rojo", 60.0, Online.HIDDEN) # del equipo rojo: solo ellos lo ven y lo cogenOnline.set_team(jugador, "rojo")(en el servidor;""para ninguno): un jugador está en un equipo cada vez. Todos los juegos lo saben:Online.get_team(jugador)yOnline.get_team_players("rojo")(sus personajes).Online.reserve(nodo, "rojo", ...): el nombre del equipo en vez de un jugador. UnArraymezcla jugadores y equipos:[quien, "rojo"].- Sigue a quien esté en el equipo: un jugador que entra en él recibe lo que tiene guardado (con
HIDDEN, aparece en su juego) y puede cogerlo; uno que sale del equipo lo pierde, como cuando algo se aleja. - Un jugador que sale de la partida sale de su equipo. Sin nadie del equipo en la partida, la reserva termina
(
OWNER_LEFT), salvo conKEEP: entonces espera al equipo (el equipo se guarda con ella) y su tiempo solo corre mientras juega alguien del equipo. - Los equipos no se guardan: ponlos otra vez cuando un jugador entra (desde sus datos
@persistent, si conserva su equipo entre partidas). - Sin red,
reserve()no hace nada ycan_take()es siempre true.
Mundos generados
Sección titulada «Mundos generados»Los generadores procedurales (Generación procedural) con Use Online
Seed hacen el mismo mundo en cada juego a partir de Online.get_world_seed() (Project Settings >
Online > World > Seed, con Advanced Settings activado, el interruptor que está arriba en la barra
lateral; 0: una al azar, la del servidor). Online trata sus prefabs con Online Mode
como si estuvieran colocados en el nivel: no se envía nada para crearlos, el servidor guarda sus
@persistent y Online.is_generated_object(nodo) los distingue.
Cada jugador comprueba con el servidor lo que generó: si una celda le salió distinta (el punto flotante de otra CPU, u otra versión del juego), recibe la del servidor.
El estado de la partida y el de cada jugador: interfaces
Sección titulada «El estado de la partida y el de cada jugador: interfaces»Un marcador, el tiempo de la partida, la ronda: no son de un objeto, son de la partida. Como el
GameState de Unreal, ponlo en una interfaz global y marca sus campos
@replicated: los decide el servidor y los recibe cada jugador (su watch se ejecuta en cada
juego; quien entra tarde los recibe como están).
Y lo que tiene cada jugador que sobrevive a su personaje (puntos, equipo, bajas), como el
PlayerState de Unreal: una interfaz player. El código del personaje recibe la de su jugador; el
HUD, la del jugador local; get_all() da la de todos, para la tabla de resultados. Cuando un jugador
se va, la suya desaparece.
interface partida global { @replicated live ronda : int = 0}
# marcador.iface.grointerface marcador player { @replicated live puntos : int = 0}
# Lenador.prefab (Mode: Player)use interface::marcador as marcador
@action fn talar() void { # se ejecuta en el servidor marcador.puntos += 10 # los del jugador de este personaje}
# HUD.uipuse interface::marcador as marcadoruse interface::partida as partida
watch marcador.puntos(valor: int) { # los puntos de este jugador etiqueta_puntos.text = str(valor)}Como en los objetos, lo que un jugador escriba en un campo replicado no cuenta: vuelve al valor del
servidor (con un aviso). Cámbialos en el código del servidor: una @action, un objeto del mundo.
@persistent también vale ahí: en una interfaz player, el servidor lo guarda para ese jugador entre
partidas (aparte de lo que guarda su personaje); en una global, es del mundo, como el de un objeto del
mundo.
interface marcador player { @replicated @persistent live puntos : int = 0 # los puntos del jugador, también la próxima partida}Los datos guardados de cada jugador
Sección titulada «Los datos guardados de cada jugador»@persistent junto a @replicated u @owner en el personaje, y el servidor lo guarda para ese
jugador: lo carga cuando entra, guarda lo que cambió cada pocos segundos y lo guarda cuando se va.
# Lenador.prefab (Mode: Player)@owner @persistent pub live madera : int = 0 # solo la ve su jugador@replicated @persistent pub mut nivel : int = 1 # la ven todos- Sin base de datos que programar: el servidor guarda un archivo SQLite
(
user://online/players.db; Project Settings > Online > Persistence, con Advanced Settings activado, el interruptor que está arriba en la barra lateral). - Un jugador es el mismo en cada partida: su cuenta cuando inicia sesión (ver
Iniciar sesión) o, si no, una clave de su instalación
(
--online-player=nombreoGOBU_ONLINE_PLAYERpara elegirla). El editor da a cada juego que lanza la suya. - Si los datos guardados no se pueden leer, el jugador no entra, así nunca se pisan.
- Hasta 256 KB por jugador. Añadir una variable más adelante no rompe nada (empieza con su valor por defecto).
- Sin red el juego lo guarda igual.

El estado guardado del mundo
Sección titulada «El estado guardado del mundo»El mismo @persistent en un objeto del mundo (Mode: Shared) colocado en el nivel guarda su estado entre
partidas: el servidor lo carga al empezar y lo guarda como el de los jugadores (un árbol cortado, un
cofre abierto, una puerta abierta siguen así la próxima vez).
# Cofre.prefab (Mode: Shared), colocado en el nivel@replicated @persistent pub live abierto : bool = false
@action pub fn abrir() void { set abierto = true}- Cada objeto se guarda por su nivel y su ruta en él (
world:res://niveles/bosque.scene:Cofre): renombrarlo o moverlo dentro del nivel lo hace empezar de nuevo. - Los objetos creados durante la partida (la madera que suelta un árbol) no se guardan: guarda lo que significan en un objeto colocado (cuánta madera queda) o en los datos de los jugadores.
- Los valores guardados llegan después de
_ready(aún ve los de por defecto): hazloslivey aplícalos en unwatch, que se ejecuta cuando se cargan, en el servidor y en cada jugador. - Un objeto quitado durante la partida vuelve con el nivel; para que no vuelva, guarda eso
(
@persistent ... live quitado : bool) y quítalo en suwatch.
Conectar
Sección titulada «Conectar»Nada que programar: un nivel con objetos online se conecta solo (Project Settings > Online > Session > Start: Automatic; o Host, Join, Dedicated Server, Off). Automatic es una partida rápida: en una red local el juego busca durante un segundo una partida del mismo proyecto con sitio y se une, o abre una que encuentran los siguientes jugadores. Dos ordenadores de la misma red juegan juntos sin escribir nada. Session > Mode separa las partidas (los jugadores de “bosque” solo se encuentran con los de “bosque”).
Session > Mode, Session > Host Migration y las secciones Sync, World y Persistence solo se ven con Advanced Settings activado (el interruptor que está arriba en la barra lateral de Project Settings).

Desde código: Online.quick_match("bosque", 4), Online.host(), Online.join("ip"),
Online.serve(), Online.leave(). Sin puerto, host(), join() y serve() usan Session > Port.
Un menú o una pantalla de login antes del mundo: el juego se conecta en el primer nivel con objetos online (y, si el servidor pide login, cuando ya inició sesión). Cuando una partida termina, el siguiente nivel con objetos online se vuelve a conectar. Session > Server Level es el nivel que juega un servidor dedicado: empieza ahí y no en el menú de los jugadores.
Acciones que responden al momento: @predicted
Sección titulada «Acciones que responden al momento: @predicted»Una @action se ejecuta en el servidor, así que lo que cambia llega al jugador que la pidió después del
viaje de ida y vuelta: con mucho ping, el árbol tiembla un instante después del hachazo. Con
@predicted se ejecuta además al momento en el juego del propio jugador:
@action @predicted pub fn talar(desde: Vector2) void { golpes += 1 # se ve aquí al momento; el valor del servidor lo sustituye al llegar temblor = 0.24}Lo que cambia de las variables @replicated queda como previsto hasta que llegan los valores del
servidor, que lo sustituyen. Si el servidor no lo hace (la rechazó: el jugador estaba demasiado lejos o
el árbol ya estaba cortado), los valores vuelven a los del servidor pasado Project Settings > Online >
Sync > Prediction Timeout (1 s); un watch sobre ellas se ejecuta las dos veces. Como el código local
de una copia, la predicción no envía otras @action y los objetos online que crea se quitan: llegan los
del servidor. Úsala para lo que el jugador debe ver responder al momento; las reglas (lo que cuenta)
siguen en la ejecución del servidor, como en cualquier @action.
Lo que ven todos: @everyone
Sección titulada «Lo que ven todos: @everyone»Una explosión, un sonido, la cámara que tiembla: cosas que todos los jugadores deben ver u oír, pero
que no son estado (no hay nada que guardar ni corregir). Una función @everyone se ejecuta en todos
los juegos: al momento en el que la llama, después en los demás.
# Bomba.prefab (Mode: Shared)@everyone pub fn explotar() void { EffectManager.play(EffectManager.EXPLOSION, position, EffectManager.LARGE) AudioManager.play_sound_at_location(boom_snd, position)}
@action pub fn golpear() void { vida -= 1 if vida <= 0 { explotar() # decide el servidor, lo ven todos }}- Llamada desde el servidor (dentro de una
@action, por ejemplo) se ejecuta allí y en el juego de cada jugador. - Llamada por un jugador se ejecuta al momento en su juego y el servidor la envía a los demás. En el objeto de un jugador solo la puede llamar ese jugador (la llamada de otro no se ejecuta, con un aviso); en un objeto del mundo, cualquiera.
- Lo que una función
@everyonellama de otras@everyonese ejecuta en cada juego sin volver a enviarse, y lo mismo una llamada desde el código local de una copia (cada copia ya ejecuta ese código). - Con una
@action @predicted, el jugador que la pide ya ejecutó sus llamadas@everyoneen la predicción: el servidor solo las envía a los demás. - Sin red es una función normal.
Personajes que no pueden hacer trampa: Max Player Speed
Sección titulada «Personajes que no pueden hacer trampa: Max Player Speed»Cada jugador mueve su propio personaje y su juego envía dónde está. Un juego modificado podría enviar
cualquier posición (un salto de punta a punta del mapa). Project Settings > Online > Sync > Max Player
Speed es lo más rápido que puede ir un personaje, en píxeles por segundo (metros en 3D); el servidor
devuelve lo que va más rápido: los demás jugadores nunca ven el salto y el personaje del tramposo vuelve
a donde estaba. 0 (por defecto) no comprueba nada.

Pon lo más rápido que el personaje puede ir de verdad (corriendo, con un impulso, cayendo), con algo de
margen: el servidor tolera los paquetes que la red entrega de golpe. Un personaje más rápido que el resto
(un vehículo, un potenciador) tiene el suyo con Online.set_max_speed(personaje, 900) en el servidor.
Mover lejos un personaje a propósito (reaparecer, un portal) lo hace el servidor, así no cuenta como
trampa: Online.teleport(personaje, posición) dentro de una @action. El juego del jugador lo pone allí
también.
@action pub fn reaparecer() void { Online.teleport(jugador, punto_de_salida)}Mundos grandes: Interest Distance
Sección titulada «Mundos grandes: Interest Distance»Por defecto cada jugador recibe todos los cambios de todos los objetos. En un mundo grande casi todos están lejos: Project Settings > Online > Sync > Interest Distance (píxeles, metros en 3D) es lo cerca que tiene que estar algo del personaje de un jugador para que ese jugador lo tenga:
- Lo que está más lejos se va del juego de ese jugador: un objeto creado durante la partida (madera tirada, el personaje de otro jugador) se quita, y uno colocado en el nivel se oculta y deja de ejecutarse. Nada lejano cuesta allí, y un juego modificado no puede mostrar dónde están los demás.
- Cuando vuelve a estar cerca regresa con su estado completo (sus
watchse ejecutan entonces): un árbol que se cortó mientras estabas lejos aparece cortado cuando llegas. Un personaje que vuelve no cuenta como un jugador que entra (player_joined). - Las llamadas
@everyonesolo llegan a los jugadores cerca del objeto: una explosión lejana no se oye. 0(por defecto) lo envía todo a todos.
Siempre está, esté donde esté: el propio personaje del jugador y los objetos sin posición (un marcador,
un gestor de la partida). Las llamadas @action y @owner no se filtran.
Dónde se encuentran los jugadores: el proveedor
Sección titulada «Dónde se encuentran los jugadores: el proveedor»Project Settings > Online > Session > Provider elige cómo se conectan los juegos; todo lo demás
(lo que se replica, @action, los datos guardados) funciona igual con cualquiera:
| Proveedor | Usa | Notas |
|---|---|---|
lan (por defecto) | ENet (UDP) | La partida rápida encuentra partidas en la red. No en el navegador. |
websocket | WebSocket (TCP) | Un juego en el navegador se une a un servidor del proyecto (un servidor dedicado, o un juego de escritorio que hace de anfitrión). La partida rápida va a Session > Address. Un jugador que entra recibe todo el mundo de golpe: hasta 4 MiB en un frame (el servidor guarda hasta 8 MiB pendientes por jugador). |
colyseus (plugin) | Un servidor Colyseus | Emparejamiento por internet: la partida rápida entra en una sala del mismo Mode con sitio o crea una; el primer juego que entra es el anfitrión. Address/Port son los del servidor Colyseus. Host, Join y un servidor dedicado también crean o entran en salas. |

Un plugin añade su proveedor con la interfaz C de los plugins de Gobu (register_online_provider en
gobu_plugin.h): pone el emparejamiento y pasa los paquetes; el motor hace el resto.
En Android, un juego solo se conecta si su paquete pide el permiso INTERNET. Activar el plugin
Colyseus lo marca en los presets de Android; con lan o websocket, marca tú Permissions >
Internet (un juego que no va online no lo pide).

Cuando el anfitrión se va
Sección titulada «Cuando el anfitrión se va»Cuando el anfitrión es un jugador y se va, la partida sigue: el jugador que entró primero después del
anfitrión pasa a ser el anfitrión. El mundo continúa desde lo que tenía su copia (el último estado que
mandó el anfitrión anterior), desde ese momento ejecuta el código del mundo y sigue guardando los datos
@persistent de los jugadores con lo que tiene la partida. Los demás jugadores solo pierden el
personaje del anfitrión que se fue. Online.host_changed avisa a cada juego; Online.is_server() dice
si ahora es el anfitrión.
- Con un proveedor que reenvía (Colyseus) los jugadores siguen conectados a través de él.
- En LAN el nuevo anfitrión abre la partida donde está y los demás se vuelven a conectar a él, cada uno como el mismo jugador (si no responde, ocupa su lugar el siguiente en el orden).
- Con WebSocket la partida termina: un navegador no puede abrir una partida para los demás.
- Si se cierra un servidor dedicado, la partida termina: ningún jugador ocupa su lugar.
Session > Host Migration la desactiva (la partida termina entonces para todos).
En el editor, el botón de servidor junto a Play arranca el proyecto como servidor dedicado sin
ventana; mientras corre, Clients elige cuántos juegos lanza Play, y todos se unen. La salida
del servidor aparece en el panel Output como [Server]. El servidor sigue al parar el juego: pulsa
Play otra vez y los juegos nuevos se unen al mismo mundo.

Exportar el servidor dedicado
Sección titulada «Exportar el servidor dedicado»El botón Platforms, junto a Play, tiene para Windows (y Linux) Export Dedicated Server
(también en Project > Export). Escribe el servidor en build/server/windows/<nombre>_server.exe,
aparte del juego de los jugadores en build/windows/, sin cambiar sus ajustes de exportación:
- Corre sin ventana ni audio, y lo visual (texturas, mallas…) va como sustitutos vacíos: un servidor más pequeño que carga menos. Las animaciones se quedan, así que el código que las reproduce funciona como en el juego.
- Abre la partida él solo en Session > Port, diga lo que diga Session > Start (ese ajuste es
el de los juegos de los jugadores). En la máquina del servidor, arráncalo con
<nombre>_server.console.exepara ver su salida.<nombre>_server.exe -- --online-serve=7000usa otro puerto. - Los juegos de los jugadores se unen con Session > Start: Join y la IP del servidor en
Session > Address, o con
-- --online-join=<ip>en su línea de comandos.

Los datos guardados de cada jugador (@persistent) se quedan en la máquina del servidor, en su
carpeta de datos de usuario (user://online/).
Iniciar sesión: las cuentas de los jugadores
Sección titulada «Iniciar sesión: las cuentas de los jugadores»Cualquier servicio de login funciona igual. El juego inicia sesión con él y recibe un token, se lo
da a Online antes de conectarse, y el servidor lo comprueba. La cuenta del jugador es entonces
quién es:
- Sus datos guardados (
@persistent) siguen a su cuenta en cualquier ordenador, no a su instalación. - La contraseña nunca llega al servidor del juego: solo el token, que firmó el servicio y que caduca.
- Una cuenta juega una sola vez a la vez: si vuelve a entrar en otro sitio, el juego anterior sale
(
kicked), conservando lo que tenía.
Project Settings > Online > Login: Check (Off: sin login, cada jugador es su instalación; Services: los tokens de los servicios del plugin Authentication, que el servidor comprueba con él; Game Code: decide el código del servidor) y Allow Guests (los jugadores sin login también juegan, como su instalación).

Cómo consigue el juego su token:
- Con el plugin Authentication (Edit > Plugins > Install):
Authentication.sign_in_with("google")inicia sesión en el navegador y le da el token aOnlineél solo. Mira Autenticación. - Desde tu código, con la API del servicio (correo y contraseña, por ejemplo):
Online.login(token).
Ejemplo: Supabase con correo y contraseña
Sección titulada «Ejemplo: Supabase con correo y contraseña»El plugin Authentication con su apartado Supabase rellenado (el servidor comprueba los tokens
con él), y un nivel de login antes del mundo, con dos LineEdit, un Button, un Label y un
HTTPRequest. En el Inspector de su raíz, Game Mode > Override sin Player: ese nivel no tiene
objetos online, así que el juego se conecta en el mundo.
module Login
use actor::Correo as correo : LineEdituse actor::Clave as clave : LineEdituse actor::Entrar as entrar : Buttonuse actor::Error as error : Labeluse actor::Http as http : HTTPRequest
SUPABASE_URL :: "https://<proyecto>.supabase.co"SUPABASE_KEY :: "<anon key>" # pública: va con el juego
Credenciales :: struct { email : String = "" password : String = ""}
SesionAuth :: struct { access_token : String = ""}
on entrar.pressed() { error.text = "" datos : Credenciales = Credenciales{ .email = correo.text, .password = clave.text } http.request(SUPABASE_URL + "/auth/v1/token?grant_type=password", ["apikey: " + SUPABASE_KEY, "Content-Type: application/json"], HTTPClient.METHOD_POST, datos.to_json())}
on http.request_completed(result: int, code: int, headers: []String, body: []u8) { if code != 200 { error.text = "Correo o contraseña incorrectos." return } sesion : SesionAuth = SesionAuth.from_json(body.get_string_from_utf8()) Online.login(sesion.access_token) SceneManager.load("mundo")}El mundo no necesita nada más: se conecta solo con ese token y el servidor lo comprueba. Para oír la respuesta:
on Online.logged_in(cuenta: String) { print($"Dentro como {cuenta}")}
on Online.login_failed(motivo: String) { SceneManager.load("login") # el motivo dice por qué: caducado, otro servicio...}
on Online.kicked(motivo: String) { SceneManager.load("login") # esta cuenta empezó a jugar en otro sitio}- El login también puede ser una pantalla encima del mundo (un
.uip): con Check activo, el nivel espera aOnline.login()para conectarse, y sus reglas también esperan. - Session > Server Level es el nivel que juega el servidor dedicado (como el Server Default Map de Unreal): empieza en el mundo, no en la pantalla de login.
La comprobación propia del servidor: Game Code
Sección titulada «La comprobación propia del servidor: Game Code»Para un servicio que no da un JWT (un ticket de Steam, PlayFab, las sesiones de tu propio servidor), Check: Game Code: el código del servidor recibe cada token y decide. En el prefab de reglas (solo corren en el servidor):
on Online.login_requested(id: int, token: String) { # Pregunta aquí a tu servicio (un HTTPRequest, su SDK). Un token de prueba: "ok:<cuenta>". if token.begins_with("ok:") { Online.accept_login(id, token.trim_prefix("ok:")) } else { Online.reject_login(id, "Token desconocido") }}El jugador espera hasta 30 segundos a accept_login() o reject_login(): la respuesta puede llegar
después, tras preguntar al servicio.
Conviene saber
Sección titulada «Conviene saber»- Check: Services necesita el plugin Authentication en el proyecto (el servidor es el mismo proyecto).
- Un anfitrión que también juega (no un servidor dedicado) también inicia sesión. Con Check:
Services su cuenta sale de su token. Con Game Code sus reglas reciben su
login_requested(id 1) al empezar a hospedar, como el de cualquier jugador: aceptado, sus datos guardados van con su cuenta desde entonces; rechazado, sale de la partida. - Los juegos que lanza el editor pueden jugar sin login (como invitados), así se prueba un nivel por su cuenta. Un servidor exportado siempre lo pide, salvo con Allow Guests.
Online.get_account(id): la cuenta de un jugador (vacía para un invitado), en el servidor y en cada juego.Online.kick(id, "motivo")en el servidor echa a un jugador: a su juego le llegakicked(motivo)y despuésdisconnected.- El token viaja cuando el jugador se conecta. Las conexiones todavía no van cifradas: los tokens que caducan (los de Supabase y Firebase duran una hora) limitan lo que vale uno copiado.
Ver lo que viaja: Debugger > Online
Sección titulada «Ver lo que viaja: Debugger > Online»Cada juego que se lanza desde el editor tiene su pestaña en el Debugger, con el nombre de lo
que es en la partida (Server, Host, o la clave del jugador: player1, player2…), y
dentro una pestaña Online:
- La partida: qué es este juego, cuántos jugadores hay, y lo que envía y recibe por segundo.
- Los objetos online: su modo, dónde se ejecutan (el servidor o un jugador; this game si es
aquí), lo que cada uno envía y recibe por segundo, y qué cambió (las claves del estado, las
@actionpedidas). Se filtran por nombre, o se ven solo los que envían o reciben ahora. - Los jugadores: su id, su clave (quién es para sus datos guardados), su personaje y su ping.
- Los valores del objeto seleccionado: sus variables
@replicatedy@ownertal como las tiene este juego (los@ownerde otro jugador no llegan a este juego, así que no se listan). - Lo que pasó: quién entró y salió, los objetos creados y quitados en todos, cada
@actioncon sus argumentos, los datos guardados, y los avisos: un jugador que escribe un valor@replicated(vuelve al del servidor), una@actionrechazada porque el objeto no es de ese jugador, un objeto online creado en un jugador, que solo ve él.

El servidor dedicado también tiene su pestaña: el mundo como lo ve el servidor, sus errores y su árbol en vivo.
Jugadores que entran y salen, y la conexión
Sección titulada «Jugadores que entran y salen, y la conexión»Online avisa a cada juego de lo que pasa con la partida:
| Señal | Cuándo |
|---|---|
player_joined(id) | Un jugador está en la partida (recibió su personaje) |
player_left(id) | Un jugador se fue (se desconectó). No cuando solo desaparece su personaje: lejos (Interest Distance) o liberado por el código del juego |
disconnected | Este juego ya no está en la partida: el servidor la cerró o se perdió la conexión |
connection_failed | No se pudo entrar |
host_changed | El anfitrión se fue y otro jugador ocupó su lugar (antes llega su player_left) |
logged_in(cuenta) | El servidor dejó entrar a este juego con esa cuenta (Iniciar sesión) |
login_failed(motivo) | El servidor no dejó entrar a este juego: el motivo dice por qué |
kicked(motivo) | El servidor echó a este juego (después, disconnected) |
on Online.player_left(id: int) { print($"El jugador {id} se fue")}
on Online.disconnected() { SceneManager.load("menu_principal") # de vuelta al menú}Un juego que se cierra o una red que se cae sin avisar se nota cuando deja de responder, al cabo de unos segundos.
Lo que puedes preguntar a Online
Sección titulada «Lo que puedes preguntar a Online»| Función | Da |
|---|---|
Online.get_role() | ROLE_OFFLINE, ROLE_HOST, ROLE_SERVER o ROLE_CLIENT |
Online.is_mine(nodo) | Si este juego ejecuta ese objeto (siempre, sin red) |
Online.player_of(nodo) | El personaje al que pertenece un actor, o null |
Online.get_player_ids() / get_player(id) | Los jugadores y sus personajes (null si no tiene, o está lejos) |
Online.get_my_id() | El id de este jugador |
Online.teleport(nodo, posición) | (Servidor) lleva el personaje de un jugador allí, en todos los juegos |
Online.set_max_speed(nodo, velocidad) | (Servidor) lo más rápido que puede ir ese personaje |
Online.login(token) | El token del servicio de login con el que este juego se conecta |
Online.get_account(id) | La cuenta de un jugador (vacía para un invitado) |
Online.kick(id, motivo) | (Servidor) echa a un jugador |
Online.reserve(nodo, jugadores, segundos, flags) / release(nodo) | (Servidor) guarda un objeto del mundo para unos jugadores (Botín para un jugador) |
Online.can_take(nodo, jugador) | Si ese jugador puede cogerlo |