Ir al contenido
Descargar
Guía de Gobu

Flujo del juego: managers

Gobu trae un conjunto de singletons, los managers, para lo que todo juego necesita: cambiar de escena, crear y encontrar entidades, mostrar interfaces y reproducir sonidos. Todos buscan por nombre de archivo, sin ruta ni extensión.

SingletonClasePara qué
SceneManagerGrostSceneManagerCambiar o reiniciar la escena
GetWorldGrostPrefabManagerCrear, añadir, eliminar y encontrar entidades
UiManagerGrostUiManagerInstanciar interfaces .uip
GameModeGrostGameStateJugador y HUD de la partida
AudioManagerGrostAudioManagerSonidos de usar y tirar
EffectManagerGrostEffectManagerExplosiones, anillos, humo, lluvia… en una llamada
ResourceRegistryGrostResourceRegistryRecursos del proyecto por nombre
InterfacesManagerGrostInterfaceManagerLas interfaces .iface.gro
SceneManager.load("level2") # cambia a res://.../level2.scene
SceneManager.restart() # recarga la escena actual

GetWorld es el manager de prefabs. spawn crea una instancia que todavía no está en el árbol; add_child la añade a la escena actual:

use prefab::enemy as enemy
fn spawn_enemy() void {
mut e := GetWorld.spawn("enemy")
e.position = Vector3(0, 1, 0)
GetWorld.add_child(e)
}

despawn oculta la instancia y la libera:

GetWorld.despawn(e)

count cuenta las instancias de un prefab en la escena actual, tanto las colocadas en el editor como las creadas con spawn. Una instancia deja de contar en cuanto le haces despawn() o queue_free(), sin esperar al final del frame:

GetWorld.despawn(e)
if GetWorld.count("enemy") == 0 {
print("Nivel limpio")
}

La etiqueta de una entidad es el module de su código. Spawned espera hasta que exista una (hay que usar await); SpawnedAll devuelve al momento la lista de las que hay:

@onready target : Actor = await GetWorld.Spawned("player")
mut all : Array = GetWorld.SpawnedAll("enemy")

show pone en pantalla, en su propio CanvasLayer, un .uip importado con use ui:: (sin el use el export no lo incluye) y hide lo quita; instantiate solo crea la instancia, sin añadirla:

use ui::HUD as hud_ui
mut hud : Actor = UiManager.show(hud_ui)
UiManager.hide(hud)

GameMode reúne lo que arranca una partida: qué prefab es el jugador y qué interfaz es el HUD. start crea los dos en la escena y devuelve el jugador:

GameMode.set_player_prefab("player")
GameMode.set_hud_prefab("HUD")
mut p := GameMode.start()

Después, GameMode.get_player() y GameMode.get_hud() los devuelven, y GameMode.reset() lo olvida todo.

Como Maps & Modes de Unreal, Project Settings > Application > Game Mode fija el jugador y el HUD de todos los niveles:

  • Player: el .prefab del personaje.
  • HUD: el .uip que se muestra en pantalla.
  • Start Automatically (activado por defecto): cada nivel, al estar listo, crea el jugador en su primer PlayerStart y muestra el HUD, sin código. Un nivel que ya tiene su personaje (colocado con Online > Mode: Player, o creado por su código) lo conserva y solo recibe el HUD.

Project Settings > Application > Game Mode: Player, HUD, Start Automatically, Min Players y Rules

Un nivel puede cambiarlos, como World Settings > GameMode Override de Unreal: selecciona la raíz del nivel y activa Game Mode > Override en el inspector. Entonces cuentan su propio Player, HUD y Start Automatically (un menú principal sin jugador ni HUD: Override activado y los dos vacíos). Se guardan con el nivel.

La raíz del nivel seleccionada, con Game Mode > Override activado en el inspector

Como AGameMode de Unreal, la partida pasa por tres estados (GameMode.get_match_state()): MATCH_WAITING_TO_START, MATCH_IN_PROGRESS y MATCH_WAITING_POST_MATCH, con las señales match_started, match_ended y match_state_changed. Cada nivel empieza una nueva:

  • Min Players (Project Settings > Application > Game Mode, 1 por defecto): la partida espera a que haya esos jugadores y entonces empieza sola. GameMode.start_match() la empieza igualmente y GameMode.end_match() la termina.
  • Rules: un .prefab con el código de la partida (qué puntúa, cuándo termina), como el Blueprint del GameMode de Unreal. Se crea en cada nivel solo donde se decide la partida: sin red, o en el servidor (dedicado o anfitrión) de una partida online; los jugadores nunca lo ejecutan. Un nivel puede tener las suyas (o ninguna) en su Game Mode.
  • GameMode.restart_player(personaje, tag) devuelve un personaje a un PlayerStart (con ese tag; por turnos), como RestartPlayer de Unreal; en red, como Online.teleport().
Reglas.prefab
use interface::partida as partida
on Online.player_joined(id: int) {
GameMode.restart_player(Online.get_player(id), "salida")
}
fn _process(_delta: float) void {
if partida.ronda >= 10 and GameMode.get_match_state() == GameMode.MATCH_IN_PROGRESS {
GameMode.end_match()
}
}

El estado de la partida se decide sin red o en el servidor, y en red lo recibe cada jugador.

Lo que el código fija con set_player_prefab/set_hud_prefab va primero; GameMode.start() usa el Game Mode del nivel para lo que el código no fijó. Con Online > Mode: Player en el jugador del Game Mode, cada jugador de una partida online recibe uno (ver Online).

Como en Unreal, un PlayerStart en el nivel dice dónde empieza un jugador. El título del Inspector conserva su nombre completo, PlayerStart2D (PlayerStart3D en un proyecto 3D; ver Un nombre según el tipo de proyecto). En el editor se ve como una cápsula del tamaño de un personaje; en 3D, con una flecha hacia donde mirará.

Un PlayerStart seleccionado en un nivel 2D: su cápsula en el visor y su Tag en el inspector

  • GameMode.start() crea su jugador en el primer PlayerStart del nivel (en el orden del árbol).
  • El personaje colocado en el nivel con Online > Mode: Player también empieza en el primero, antes de su _ready: su código ya ve dónde está. Un personaje que crea el código del nivel se queda en la posición que le da ese código.
  • En una partida online, los jugadores que entran empiezan en los siguientes, por turnos cuando hay más jugadores que PlayerStarts (ver Online).
  • Sin ninguno no se mueve nada: el personaje se queda donde se colocó.

En 2D solo cuenta la posición; en 3D el personaje además mira hacia donde mira el PlayerStart. Su Tag permite elegirlo desde el código: las entradas de un nivel, la base de un equipo. Para reaparecer:

fn reaparecer(jugador: Spatial2D) void {
mut salida := GameMode.get_player_start("puerta") as PlayerStart2D
jugador.global_position = salida.global_position
}

GameMode.get_player_start(tag, index) devuelve el PlayerStart número index con ese tag (cualquiera si el tag está vacío), o null si no hay.

Para sonidos que no necesitas controlar después. El sonido se importa con use audio:::

use audio::coin as coin_snd
fn collect() void {
AudioManager.play_sound(coin_snd)
AudioManager.play_sound_at_location(coin_snd, Vector2(10, 20))
AudioManager.play_sound_at_location_3d(coin_snd, Vector3.ZERO)
}

Más en Audio.

Efectos 2D ya hechos (el “Do Effect” de GameMaker); las partículas desaparecen solas:

fn golpe() void {
EffectManager.play(EffectManager.EXPLOSION, position)
EffectManager.play(EffectManager.RING, position, EffectManager.LARGE, Color.CYAN)
}

Más en Efectos rápidos.

El registro de recursos del proyecto, por espacio de nombres y nombre de archivo. Los espacios son scene, prefab, ui, audio, texture y component:

ResourceRegistry.load_resource("texture", "icon")
ResourceRegistry.has_resource("prefab", "enemy")
ResourceRegistry.get_resource_names("scene")

Indexa las interfaces .iface.gro del proyecto. En Grost las usas con use interface:: (capítulo 9); el manager es lo que hay detrás y rara vez lo llamas directamente.