Ir al contenido
Descargar
Tutoriales

Arena 3D

En este tutorial haces una arena 3D: controlas a un personaje en una plataforma, los enemigos llegan en oleadas y te persiguen, y tienes que aguantar 60 segundos sin morir. Puedes golpear a los enemigos cercanos con Espacio.

Es la continuación del Plataformas 2D. Aquí el foco está en la concurrencia y el estado reactivo:

  • La escena lanza las oleadas con una corrutina (spawn, loop { }, await sleep(...)).
  • Los enemigos encuentran al jugador con await GetWorld.Spawned("player").
  • La vida de cada enemigo es una variable live y muere con upon hp <= 0 { }.
  • “Aguanta 60 segundos o muere” es un race { }.

Crea un proyecto 3D nuevo desde el gestor de proyectos. Como en el tutorial anterior, los archivos van en resources/ y Gobu los encuentra por nombre de archivo.

Crea tres recursos de Enhanced Input:

  1. move.inputaction: value_type = VALUE_TYPE_AXIS_2D.
  2. attack.inputaction: value_type = VALUE_TYPE_BOOL, con un InputTriggerPressed para que dispare una sola vez por pulsación.
  3. combat.inputcontext: un InputMappingContext con estos mapeos:
TeclaAcciónModificadores
Dmoveninguno
AmoveInputModifierNegate
WmoveInputModifierSwizzle
SmoveInputModifierSwizzle + InputModifierNegate
Espacioattackninguno

move da un Vector2: x es izquierda/derecha y y es adelante/atrás. En 3D, “adelante” es -Z, así que el jugador lo convierte a Vector3(x, 0, -y).

La vida del jugador, el tiempo que queda y el mensaje final los escriben la escena y los enemigos, y los lee el HUD. Van en una interfaz global, arena.iface.gro:

interface arena global {
live health : int = 100 { set(value): field = clamp(value, 0, 100) }
live time_left : int = 60
live message : String = ""
fn apply_damage(value: int) void {
set health -= value
}
}

El setter mantiene health entre 0 y 100. Como health es live, set además avisa a quien la observe con watch.

Crea player.prefab:

  • Player (CharacterBody3D), la raíz, a un metro sobre el suelo.
    • MeshInstance3D con una CapsuleMesh.
    • CollisionShape3D con una CapsuleShape3D.

Su código:

module Player
use actor::Player as player : CharacterBody3D
use input::combat as controls
@editable mut speed : float = 6.0
@editable mut attack_range : float = 2.5
fn _ready() void {
controls.enable(0)
}
fn _physics_process(_delta: float) void {
input : Vector2 = controls.move.value()
player.velocity = Vector3(input.x, 0.0, -input.y) * speed
player.move_and_slide()
}
on controls.attack.triggered() {
for e in GetWorld.SpawnedAll("enemy") {
enemy : Spatial3D = e as Spatial3D
if enemy.global_position.distance_to(player.global_position) < attack_range {
e.hit(1)
}
}
}
  • module Player le da al jugador la etiqueta player. Los enemigos la usan para encontrarlo.
  • GetWorld.SpawnedAll("enemy") devuelve, en ese momento, la lista de enemigos de la escena.
  • e.hit(1) llama a una función pub del código del enemigo (la verás en el paso siguiente).

Crea enemy.prefab:

  • Enemy (CharacterBody3D), la raíz.
    • MeshInstance3D con una BoxMesh (dale un material rojo para distinguirlo).
    • CollisionShape3D con una BoxShape3D del mismo tamaño.

Su código:

module Enemy
use actor::Enemy as body : CharacterBody3D
use interface::arena as arena
@editable mut speed : float = 3.0
@editable mut damage : int = 10
live hp : int = 3
mut cooldown : float = 0.0
@onready target : Actor = await GetWorld.Spawned("player")
pub fn hit(amount: int) void {
set hp -= amount
}
upon hp <= 0 {
body.destroy()
}
fn _physics_process(delta: float) void {
if target == null {
return
}
goal : Vector3 = (target as Spatial3D).global_position
mut dir : Vector3 = goal - body.global_position
dir.y = 0.0
if dir.length() < 1.5 {
body.velocity = Vector3.ZERO
cooldown -= delta
if cooldown <= 0.0 {
arena.apply_damage(damage)
cooldown = 1.0
}
} else {
body.velocity = dir.normalized() * speed
}
body.move_and_slide()
}
  • @onready target : Actor = await GetWorld.Spawned("player") espera a que exista un actor con la etiqueta player. Hasta entonces target es null, por eso _physics_process lo comprueba primero.
  • hp es live: set hp -= amount lo cambia y avisa.
  • upon hp <= 0 { } se ejecuta una sola vez, la primera vez que la condición es cierta. No hace falta comprobar la vida después de cada golpe.
  • Cuando el enemigo está pegado al jugador, le quita vida una vez por segundo a través de la interfaz arena. No sabe nada del HUD.

Crea HUD.uip:

  • HUD (Control), la raíz, a pantalla completa.
    • Health (Label), arriba a la izquierda.
    • Time (Label), arriba a la derecha.
    • Message (Label), centrado, con el texto vacío.

Su código:

module HUD
use actor::Health as health_label : Label
use actor::Time as time_label : Label
use actor::Message as message_label : Label
use interface::arena as arena
@onready watch arena.health(value: int) {
health_label.text = $"HP: {value}"
}
@onready watch arena.time_left(value: int) {
time_label.text = $"{value} s"
}
watch arena.message(value: String) {
message_label.text = value
}

Crea arena.scene y márcala como escena principal:

  • Arena (Spatial3D), la raíz.
    • Floor (StaticBody3D) con un MeshInstance3D (PlaneMesh de 30 × 30) y un CollisionShape3D (BoxShape3D fina del mismo tamaño).
    • DirectionalLight3D, inclinada, con sombras si quieres.
    • Camera3D alta y mirando hacia abajo al centro de la arena.
    • Una instancia de player.prefab en el centro.

El código de la escena dirige la partida:

module Arena
use interface::arena as arena
use ui::HUD as hud_ui
use prefab::enemy as enemy_prefab
SURVIVE_TIME :: 60
SPAWN_RADIUS :: 12.0
mut waves : GrostFunctionState = null
async fn _ready() void {
UiManager.show(hud_ui)
waves = spawn spawn_waves()
won : bool = race {
await survive()
await player_dies()
}
waves.cancel()
for e in GetWorld.SpawnedAll("enemy") {
GetWorld.despawn(e)
}
if won == true {
set arena.message = "¡Sobreviviste!"
} else {
set arena.message = "Has caído"
}
await sleep(3.0)
InterfacesManager.clear()
SceneManager.restart()
}
async fn spawn_waves() void {
mut wave := 1
loop {
for i in range(wave * 3) {
spawn_enemy()
}
await sleep(8.0)
wave += 1
}
}
fn spawn_enemy() void {
angle : float = randf() * TAU
mut enemy := GetWorld.spawn("enemy")
enemy.position = Vector3(cos(angle) * SPAWN_RADIUS, 1.0, sin(angle) * SPAWN_RADIUS)
GetWorld.add_child(enemy)
}
async fn survive() bool {
for s in range(SURVIVE_TIME) {
set arena.time_left = SURVIVE_TIME - s
await sleep(1.0)
}
set arena.time_left = 0
return true
}
async fn player_dies() bool {
loop {
if arena.health <= 0 {
return false
}
await next_frame()
}
}

Paso a paso:

  • _ready usa await, así que es async fn.
  • spawn spawn_waves() arranca la corrutina de oleadas sin esperarla y guarda la tarea en waves. La corrutina es un loop { } infinito: cada oleada trae tres enemigos más que la anterior, con 8 segundos entre oleadas.
  • race { } ejecuta survive() y player_dies() a la vez. La primera en terminar gana, la otra se cancela, y won recibe el valor de la ganadora: true si aguantaste, false si caíste.
  • waves.cancel() detiene las oleadas, y GetWorld.despawn quita a los enemigos que quedan.
  • Tras tres segundos, InterfacesManager.clear() devuelve la interfaz a sus valores iniciales y SceneManager.restart() recarga la escena.

Pulsa ejecutar. Muévete con WASD y golpea con Espacio a los enemigos que se acercan: tres golpes y desaparecen. El contador baja de 60 a 0; si llega a cero, ganas. Si tu vida llega a 0 antes, pierdes. En los dos casos la partida vuelve a empezar a los tres segundos.

  • Pon la vida de cada enemigo en una interfaz por instancia (sin global) para que una barra de vida sobre su cabeza la observe con watch.
  • Usa defer { } en spawn_waves para hacer algo cuando la corrutina se cancele.
  • Guarda la oleada máxima alcanzada con @persistent, como en el tutorial anterior.
UsasteCapítulo
async fn, await, spawn, loop { }, sleep, next_frame, race { }, cancel()Concurrencia
live, set, watch, uponEstado reactivo
Interfaces globales con setter y funcionesInterfaces
use actor::, GetWorld, UiManager, SceneManagerImportar con use
pub fnFunciones
@onready, @editableAnotaciones
Acciones, disparadores, modificadoresInput