Ir al contenido
Descargar
Guía de Gobu

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.

Selecciona la raíz de un prefab y cambia Inspector > Online > Mode:

ModoParaQué pasa
PlayerEl personajeCada jugador que entra tiene el suyo. Lo mueve su jugador; los demás lo ven moverse y animarse.
SharedUn objeto del mundo (un árbol, una puerta, un cofre, algo tirado en el suelo)Lo ejecuta el servidor; todos ven lo mismo.
Shared + Local CodeUn objeto del mundo que además dibuja algo para cada jugadorComo 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.
OffTodo lo demásCada juego tiene el suyo.

El prefab del jugador abierto: en el Inspector de su raíz, la sección Online con Mode en Player

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.

AnotaciónEnHaceEn Unreal
@replicatedUna variableLa decide el servidor; la reciben todosUPROPERTY(Replicated)
@ownerUna variableLa decide el servidor; solo la recibe el dueño del objetoCOND_OwnerOnly
@actionUna funciónSe ejecuta en el servidor. En un personaje solo la pide su jugador; en un objeto del mundo, cualquieraRPC Server
@ownerUna funciónSe ejecuta en el juego del dueño del objeto; la pide el servidorRPC Client
@predictedUna @actionSe ejecuta también al momento en el juego que la pide; los valores del servidor sustituyen la predicciónPredicción en el cliente
@everyoneUna funciónSe ejecuta en todos los juegos: al momento en el que la llama, después en los demásRPC NetMulticast
@persistentUna variable @replicated/@ownerEl servidor la guarda para ese jugador entre partidasPersistencia 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.

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 : Sprite2D
use 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.
}
}

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 tocarla
on 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): jugadores es un personaje, un id de jugador o un Array de ellos (un equipo); segundos = 0 la guarda hasta Online.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 @action sobre 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: comprueba Online.can_take(nodo, quien) donde se recoge.

  • on Online.reservation_ended(nodo: Actor, motivo: int) (en el servidor): Online.TIMEOUT, Online.OWNER_LEFT, Online.RELEASED o Online.LIMIT, antes de que pase a ser de cualquiera o se quite; llamar a Online.reserve() ahí la guarda para otro (el siguiente del equipo, por ejemplo).

  • Online.get_reserved_for(nodo) y Online.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). Sin KEEP la reserva dura la partida, y un anfitrión nuevo (migración) empieza sin ninguna.

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 partida
Online.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_TIME corre 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_ended con Online.LIMIT (se quita con DESTROY_AFTER, si no pasa a ser de cualquiera) y ya no se guarda. Online.get_kept_objects(quien) (o get_kept_objects(), todas) te deja elegir a ti qué se va. Sin límite, el servidor avisa una vez cuando hay muchas.
  • KEEP es 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.

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 @action de un jugador (el talar() del árbol que suelta la madera) se guarda para ese jugador. Sin llamar a Online.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 segundos y flags de Online.reserve().

La raíz de un prefab con Mode: Shared: en su sección Online, Reserve For en Who Asked, Reserve Seconds en 30 y los Reserve Flags con Hidden marcado

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

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 cogen
  • Online.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) y Online.get_team_players("rojo") (sus personajes).
  • Online.reserve(nodo, "rojo", ...): el nombre del equipo en vez de un jugador. Un Array mezcla 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 con KEEP: 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 y can_take() es siempre true.

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.

partida.iface.gro
interface partida global {
@replicated live ronda : int = 0
}
# marcador.iface.gro
interface 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.uip
use interface::marcador as marcador
use 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
}

@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=nombre o GOBU_ONLINE_PLAYER para 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.

La sección Persistence de Project Settings > Online: Database (user://online/players.db), Save Interval, Max Kept Objects per Player y Max Kept Objects

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): hazlos live y aplícalos en un watch, 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 su watch.

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

Project Settings > Online, con Advanced Settings activado: las secciones Session, Sync, World, Persistence y Login, con Start (Automatic) y Mode marcados

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.

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 @everyone llama de otras @everyone se 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 @everyone en 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.

La sección Sync de Project Settings > Online: Rate, Prediction Timeout, Max Player Speed e Interest Distance

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

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 watch se 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 @everyone solo 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:

ProveedorUsaNotas
lan (por defecto)ENet (UDP)La partida rápida encuentra partidas en la red. No en el navegador.
websocketWebSocket (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 ColyseusEmparejamiento 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.

La lista Provider abierta en la sección Session: None, lan y websocket

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

La página Android de Project Settings > Platforms, entre sus Permissions: Internet

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.

La barra de ejecución sobre el viewport: el botón de servidor entre los botones de Play y Platforms

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.exe para ver su salida. <nombre>_server.exe -- --online-serve=7000 usa 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.

El botón Platforms abierto con el submenú de Windows Desktop: Export Dedicated Server

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

La sección Login de Project Settings > Online con la lista Check abierta: Off, Services y Game Code

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 a Online él solo. Mira Autenticación.
  • Desde tu código, con la API del servicio (correo y contraseña, por ejemplo): Online.login(token).

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 : LineEdit
use actor::Clave as clave : LineEdit
use actor::Entrar as entrar : Button
use actor::Error as error : Label
use 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 a Online.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.

  • 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 llega kicked(motivo) y después disconnected.
  • 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.

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 @action pedidas). 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 @replicated y @owner tal como las tiene este juego (los @owner de 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 @action con sus argumentos, los datos guardados, y los avisos: un jugador que escribe un valor @replicated (vuelve al del servidor), una @action rechazada porque el objeto no es de ese jugador, un objeto online creado en un jugador, que solo ve él.

La pestaña Online del Debugger sin ningún juego en marcha: la partida, los objetos online (Object, Mode, Runs on, Sends, Receives, Changes), What happened, los jugadores (Player, Key, Character, Ping) y los valores

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ñalCuá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
disconnectedEste juego ya no está en la partida: el servidor la cerró o se perdió la conexión
connection_failedNo se pudo entrar
host_changedEl 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.

FunciónDa
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