Bloque 5 on Documentación

Tema 9. Introducción a LibGDX

Mon, 01 Jan 0001 00:00:00 +0000

Tema 9. Introducción a LibGDX

Información del tema

Bloque: B5 — Motores de juego: análisis e introducción a LibGDX
Duración aproximada: 3 horas

Resultados de Aprendizaje

RA4 — Selecciona y prueba motores de juegos analizando la arquitectura de juegos 2D y 3D.
RA5 — Desarrolla juegos 2D y 3D sencillos utilizando motores de juegos.

Criterios de Evaluación

Código	Criterio
RA4-a	Se han identificado los elementos que componen la arquitectura de un juego 2D y 3D.
RA4-b	Se han analizado los componentes de un motor de juegos.
RA4-c	Se han analizado entornos de desarrollo de juegos.
RA4-d	Se han analizado diferentes motores de juegos, sus características y funcionalidades.
RA4-e	Se han identificado los bloques funcionales de un juego existente.
RA4-f	Se ha reconocido la representación lógica y espacial de una escena gráfica sobre un juego existente.
RA5-a	Se ha establecido la lógica de un nuevo juego.
RA5-b	Se han creado los objetos necesarios para el juego y definido sus características.
RA5-c	Se han creado las escenas del juego y distribuido los objetos en las mismas.
RA5-e	Se han establecido las propiedades físicas de los objetos.
RA5-g	Se han utilizado cámaras y configurado la iluminación.

1. Introducción: motores de juego y LibGDX#

1.1. ¿Por qué un motor de juego?#

Cuando desarrollamos una aplicación Android convencional con Jetpack Compose, delegamos en el sistema operativo la gestión del ciclo de renderizado: el sistema decide cuándo redibujar la interfaz en respuesta a cambios de estado. Este modelo, eficiente para formularios, listas o navegación, resulta inadecuado para videojuegos, donde la pantalla debe actualizarse de forma continua —típicamente entre 30 y 60 veces por segundo— independientemente de si ha cambiado algún dato.

Tema 9. Introducción a LibGDX

Mon, 01 Jan 0001 00:00:00 +0000

Tema 9. Introducción a LibGDX

Información del tema

Bloque: B5 — Motores de juego: análisis e introducción a LibGDX
Duración aproximada: 3 horas

Resultados de Aprendizaje

RA4 — Selecciona y prueba motores de juegos analizando la arquitectura de juegos 2D y 3D.
RA5 — Desarrolla juegos 2D y 3D sencillos utilizando motores de juegos.

Criterios de Evaluación

Código	Criterio
RA4-a	Se han identificado los elementos que componen la arquitectura de un juego 2D y 3D.
RA4-b	Se han analizado los componentes de un motor de juegos.
RA4-c	Se han analizado entornos de desarrollo de juegos.
RA4-d	Se han analizado diferentes motores de juegos, sus características y funcionalidades.
RA4-e	Se han identificado los bloques funcionales de un juego existente.
RA4-f	Se ha reconocido la representación lógica y espacial de una escena gráfica sobre un juego existente.
RA5-a	Se ha establecido la lógica de un nuevo juego.
RA5-b	Se han creado los objetos necesarios para el juego y definido sus características.
RA5-c	Se han creado las escenas del juego y distribuido los objetos en las mismas.
RA5-e	Se han establecido las propiedades físicas de los objetos.
RA5-g	Se han utilizado cámaras y configurado la iluminación.

1. Introducción: motores de juego y LibGDX#

1.1. ¿Por qué un motor de juego?#

Cuando desarrollamos una aplicación Android convencional con Jetpack Compose, el sistema operativo decide cuándo redibujar la interfaz en respuesta a cambios de estado. Este modelo, eficiente para formularios y listas, resulta inadecuado para videojuegos, donde la pantalla debe actualizarse de forma continua —típicamente entre 30 y 60 veces por segundo— independientemente de si ha cambiado algún dato.

Tema 10. KotlinAsteroids — Juego de asteroides 2D completo

Mon, 01 Jan 0001 00:00:00 +0000

Tema 10: KotlinAsteroids — Juego de asteroides 2D completo

Información del tema

Bloque: B5 — Motores de juego: análisis e introducción a LibGDX
Duración aproximada: 4 horas

Este tema desarrolla un proyecto guiado completo que integra todos los conceptos del Tema 9 aplicados a un juego top-down sin gravedad: Box2D con cuerpo libre, partículas, audio y múltiples pantallas. El juego sirve como referencia de arquitectura para el proyecto propio de evaluación.

Tema 10. KotlinPlatformer — Juego 2D completo

Mon, 01 Jan 0001 00:00:00 +0000

Tema 10. KotlinPlatformer — Juego 2D completo

Información del tema

Bloque: B5 — Motores de juego: análisis e introducción a LibGDX
Duración aproximada: 4 horas

Este tema desarrolla un proyecto guiado completo que integra todos los conceptos del Tema 9: Box2D, TiledMap, partículas, animaciones, audio y múltiples pantallas. El juego sirve como referencia de arquitectura para el proyecto propio de evaluación.

Resultados de Aprendizaje

RA4 — Selecciona y prueba motores de juegos analizando la arquitectura de juegos 2D y 3D.
RA5 — Desarrolla juegos 2D y 3D sencillos utilizando motores de juegos.

Criterios de Evaluación

Código	Criterio
RA4-e	Se han identificado los bloques funcionales de un juego existente.
RA4-f	Se ha reconocido la representación lógica y espacial de una escena gráfica sobre un juego existente.
RA5-a	Se ha establecido la lógica de un nuevo juego.
RA5-b	Se han creado los objetos necesarios para el juego y definido sus características.
RA5-c	Se han creado las escenas del juego y distribuido los objetos en las mismas.
RA5-d	Se han creado materiales para determinar las propiedades finales de la superficie de un objeto.
RA5-e	Se han establecido las propiedades físicas de los objetos.
RA5-f	Se ha incorporado sonido a los diferentes eventos del juego.
RA5-g	Se han utilizado cámaras y configurado la iluminación.
RA5-h	Se han desarrollado e implantado juegos para dispositivos móviles.
RA5-i	Se han realizado pruebas de funcionamiento y optimización de los juegos desarrollados.
RA5-j	Se han documentado las fases de diseño y desarrollo de los juegos creados.

1. Diseño del juego: KotlinPlatformer#

KotlinPlatformer es un juego de plataformas lateral 2D en el que el jugador controla un personaje que corre y salta sobre plataformas, recoge monedas y evita trampas. El objetivo es alcanzar el final del nivel con el mayor número de monedas posible.

Anexo 6. Referencia rápida de LibGDX

Mon, 01 Jan 0001 00:00:00 +0000

Anexo 6: Referencia rápida de LibGDX#

Información del anexo

Tipo: Anexo de apoyo — material de consulta y profundización
Bloque: B5 — Motores de juego: análisis e introducción a LibGDX

Este anexo actúa como hoja de consulta rápida durante el desarrollo del proyecto. Recoge las clases, métodos y patrones más usados del Tema 9 y el Tema 10 (KotlinAsteroids), organizados por área temática. Las secciones de física están adaptadas a juegos top-down sin gravedad.

Anexo 6. Referencia rápida de LibGDX

Mon, 01 Jan 0001 00:00:00 +0000

Anexo 6: Referencia rápida de LibGDX#

Información del anexo

Tipo: Anexo de apoyo — material de consulta y profundización
Bloque: B5 — Motores de juego: análisis e introducción a LibGDX

Este anexo actúa como hoja de consulta rápida durante el desarrollo del proyecto. Recoge las clases, métodos y patrones más usados del Tema 9 y el Tema 10 (KotlinPlatformer), organizados por área temática.

Resultados de Aprendizaje

RA4 — Selecciona y prueba motores de juegos analizando la arquitectura de juegos 2D y 3D.
RA5 — Desarrolla juegos 2D y 3D sencillos utilizando motores de juegos.

1. Versiones y dependencias de referencia#

gradle.properties#

gdxVersion=1.13.1
ktxVersion=1.13.1-rc1
kotlinVersion=2.2.20

core/build.gradle.kts — dependencias completas#

 1dependencies {
 2    api("com.badlogicgames.gdx:gdx:$gdxVersion")
 3    api("com.badlogicgames.gdx:gdx-box2d:$gdxVersion")
 4    api("com.badlogicgames.gdx:gdx-freetype:$gdxVersion")   // fuentes TTF (opcional)
 5
 6    api("io.github.libktx:ktx-app:$ktxVersion")
 7    api("io.github.libktx:ktx-graphics:$ktxVersion")
 8    api("io.github.libktx:ktx-assets:$ktxVersion")
 9    api("io.github.libktx:ktx-math:$ktxVersion")
10    api("io.github.libktx:ktx-box2d:$ktxVersion")
11    api("io.github.libktx:ktx-tiled:$ktxVersion")
12}

android/build.gradle.kts — nativas Box2D y FreeType#

 1dependencies {
 2    implementation(project(":core"))
 3
 4    // Box2D nativas
 5    natives("com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-arm64-v8a")
 6    natives("com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-armeabi-v7a")
 7    natives("com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-x86")
 8    natives("com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-x86_64")
 9
10    // FreeType nativas (si se usa gdx-freetype)
11    natives("com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-arm64-v8a")
12    natives("com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-armeabi-v7a")
13    natives("com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-x86")
14    natives("com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-x86_64")
15}

2. Ciclo de vida — resumen visual#

AndroidLauncher.onCreate()
        │
        └─► initialize(MiJuego(), config)
                │
                ▼
        KtxGame.create()           ← inicializar batch, viewport, assets, primera pantalla
                │
                ├─► resize(w, h)   ← justo después de create() y en cada cambio de tamaño
                │
                │   ┌─────────────────────────────────────────┐
                │   │  BUCLE PRINCIPAL (~60 fps)              │
                │   │  render(delta)                          │
                │   │    ├── world.step(...)   [Box2D]        │
                │   │    ├── update entidades                 │
                │   │    └── draw()                           │
                │   └─────────────────────────────────────────┘
                │
                ├─► pause()        ← Home / llamada / bloqueo de pantalla
                ├─► resume()       ← volver a la app
                │
                └─► dispose()      ← cerrar app (puede no ejecutarse si el SO mata el proceso)
                       └── liberar: batch, assets, world, debugRenderer, particles, stage...

Métodos del ciclo de vida de KtxScreen#

Método	Se llama cuando	Acción típica
`show()`	La pantalla se activa	Configurar InputProcessor, iniciar música
`render(delta)`	Cada fotograma	update + draw
`resize(w, h)`	Cambio de tamaño	`viewport.update(w, h, true)`, `hud.resize(w, h)`
`pause()`	Pérdida de foco	Pausar música
`resume()`	Recuperar foco	Reanudar música
`hide()`	La pantalla se desactiva	(vacío en la mayoría de casos)
`dispose()`	Liberación explícita	`dispose()` en todos los recursos propios de esta pantalla

3. Renderizado — patrones de uso#

SpriteBatch con KTX#

 1// Patrón recomendado: use {} garantiza que end() siempre se llama
 2batch.use { b ->
 3    b.draw(textura, x, y, ancho, alto)
 4    b.draw(region, x, y, ancho, alto)   // TextureRegion
 5    fuente.draw(b, "Texto", x, y)
 6    particula.draw(b, delta)            // ParticleEffect
 7}
 8
 9// Sin KTX
10batch.begin()
11batch.draw(textura, x, y)
12batch.end()

ShapeRenderer#

 1// IMPORTANTE: batch debe estar cerrado (end()) antes de abrir ShapeRenderer
 2shapeRenderer.projectionMatrix = camera.combined
 3
 4// Líneas (contornos, debug)
 5shapeRenderer.begin(ShapeRenderer.ShapeType.Line)
 6shapeRenderer.color = Color.RED
 7shapeRenderer.rect(x, y, w, h)
 8shapeRenderer.circle(cx, cy, radio, 32)   // 32 = segmentos
 9shapeRenderer.line(x1, y1, x2, y2)
10shapeRenderer.end()
11
12// Relleno
13shapeRenderer.begin(ShapeRenderer.ShapeType.Filled)
14shapeRenderer.setColor(r, g, b, a)    // RGBA entre 0.0 y 1.0
15shapeRenderer.rect(x, y, w, h)
16shapeRenderer.end()

OrthogonalTiledMapRenderer#

1// Crear con el mismo unitScale que el viewport
2val renderer = OrthogonalTiledMapRenderer(tiledMap, unitScale, batch)
3
4// En render() — siempre DENTRO del mismo batch que el juego
5renderer.setView(camera)
6renderer.render()                      // todas las capas
7renderer.render(intArrayOf(0, 1))      // solo capas 0 y 1
8
9renderer.dispose()   // dispose() al cerrar la pantalla

4. Cámara y Viewport — referencia rápida#

 1// Crear viewport (elegir uno)
 2val viewport = FitViewport(WORLD_W, WORLD_H)       // barras negras, misma área siempre
 3val viewport = ExtendViewport(WORLD_W, WORLD_H)    // extiende el mundo, sin barras
 4val viewport = ScreenViewport()                    // 1:1 píxeles de pantalla
 5
 6// La cámara del viewport
 7val camera = viewport.camera as OrthographicCamera
 8camera.setToOrtho(false, WORLD_W, WORLD_H)  // false = Y crece hacia arriba
 9
10// En cada render()
11viewport.apply()           // aplica las bandas negras si procede
12camera.update()            // recalcula la matriz de proyección
13batch.projectionMatrix = camera.combined
14
15// En resize()
16viewport.update(width, height, true)  // true = centrar cámara
17
18// Seguir al jugador (con suavizado lerp)
19camera.position.x = MathUtils.lerp(camera.position.x, target.x, 5f * delta)
20camera.position.y = MathUtils.lerp(camera.position.y, target.y, 5f * delta)
21
22// Convertir toque de pantalla a coordenadas del mundo
23val touchVec = Vector3(Gdx.input.x.toFloat(), Gdx.input.y.toFloat(), 0f)
24viewport.unproject(touchVec)   // modifica touchVec in-place
25// Ahora: touchVec.x, touchVec.y = coordenadas del mundo

5. AssetManager — carga y acceso#

 1val assets = AssetManager()
 2
 3// Registrar loader de TiledMap (ANTES de encolar .tmx)
 4assets.setLoader(TiledMap::class.java, TmxMapLoader(InternalFileHandleResolver()))
 5
 6// Encolar assets para carga asíncrona
 7assets.load("atlas/juego.atlas",      TextureAtlas::class.java)
 8assets.load("mapas/nivel1.tmx",       TiledMap::class.java)
 9assets.load("audio/musica.ogg",       Music::class.java)
10assets.load("audio/salto.wav",        Sound::class.java)
11
12// Carga asíncrona (en LoadingScreen.render())
13if (assets.update()) { /* carga completa */ }
14val progreso: Float = assets.progress   // 0.0 a 1.0
15
16// Carga síncrona (bloquea)
17assets.finishLoading()
18
19// Acceso a assets ya cargados
20val atlas: TextureAtlas = assets.get("atlas/juego.atlas", TextureAtlas::class.java)
21val mapa:  TiledMap     = assets.get("mapas/nivel1.tmx",  TiledMap::class.java)
22
23// Liberación (libera TODOS los assets cargados)
24assets.dispose()

6. TextureAtlas y Animation#

 1// Cargar atlas
 2val atlas = TextureAtlas("atlas/juego.atlas")
 3
 4// Acceso por nombre
 5val region:  TextureRegion              = atlas.findRegion("moneda")
 6val regiones: Array<TextureAtlas.AtlasRegion> = atlas.findRegions("jugador_correr")
 7
 8// Crear animación
 9val frames = atlas.findRegions("jugador_correr")
10val animacion = Animation(
11    0.1f,              // duración de cada fotograma en segundos
12    *frames.toArray(), // spread operator para vararg
13    Animation.PlayMode.LOOP
14)
15
16// Obtener fotograma actual en render()
17tiempoAnim += delta
18val fotograma: TextureRegion = animacion.getKeyFrame(tiempoAnim)
19batch.draw(fotograma, x, y, w, h)
20
21// Voltear sprite horizontalmente (sin crear nueva región)
22batch.draw(region, x + w, y, -w, h)  // x desplazado + ancho negativo

7. Entrada del usuario#

 1// ── Polling (consultar cada frame) ────────────────────────────────────────
 2
 3Gdx.input.isTouched                    // true mientras el dedo esté presionado
 4Gdx.input.justTouched()                // true solo el PRIMER fotograma del toque
 5Gdx.input.x / Gdx.input.y             // posición del toque en píxeles de pantalla
 6
 7Gdx.input.isKeyPressed(Input.Keys.A)       // tecla mantenida
 8Gdx.input.isKeyJustPressed(Input.Keys.SPACE)  // tecla pulsada este fotograma
 9
10Gdx.input.accelerometerX              // inclinación izquierda-derecha (-10..10)
11Gdx.input.accelerometerY              // inclinación adelante-atrás
12
13// ── InputAdapter (eventos discretos) ─────────────────────────────────────
14
15Gdx.input.inputProcessor = object : InputAdapter() {
16    override fun touchDown(screenX: Int, screenY: Int, pointer: Int, button: Int): Boolean {
17        return true   // true = evento consumido
18    }
19    override fun keyDown(keycode: Int): Boolean {
20        if (keycode == Input.Keys.BACK) { /* botón atrás Android */ }
21        return false
22    }
23}
24
25// ── InputMultiplexer (varios receptores) ─────────────────────────────────
26
27val multiplexer = InputMultiplexer(stage, gameInput)  // stage tiene prioridad
28Gdx.input.inputProcessor = multiplexer

8. Audio#

 1// ── Sound: efectos cortos (< 5 s, cargados en memoria) ──────────────────
 2
 3val sfx: Sound = Gdx.audio.newSound(Gdx.files.internal("audio/salto.wav"))
 4// o via AssetManager:
 5val sfx: Sound = assets.get("audio/salto.wav", Sound::class.java)
 6
 7val id: Long = sfx.play(volume = 1.0f)             // devuelve ID de instancia
 8sfx.play(volume = 0.8f, pitch = 1.2f, pan = 0f)   // pitch: 0.5 (lento) a 2.0 (rápido)
 9sfx.stop(id)
10sfx.setLooping(id, true)
11sfx.dispose()
12
13// ── Music: pistas largas (streaming desde disco) ─────────────────────────
14
15val musica: Music = assets.get("audio/musica.ogg", Music::class.java)
16musica.isLooping = true
17musica.volume    = 0.6f      // 0.0 a 1.0
18musica.play()
19musica.pause()
20musica.stop()
21musica.isPlaying              // Boolean
22// NO llamar dispose() si es gestionada por AssetManager

9. Box2D — referencia completa#

Crear el World#

 1val world = World(Vector2(0f, -20f), true)  // gravedad, dormir inactivos
 2world.setContactListener(miListener)
 3
 4// Paso de simulación con tiempo fijo
 5private val TIME_STEP = 1f / 60f
 6private var accumulator = 0f
 7
 8fun step(delta: Float) {
 9    accumulator += delta.coerceAtMost(0.25f)
10    while (accumulator >= TIME_STEP) {
11        world.step(TIME_STEP, 8, 3)
12        accumulator -= TIME_STEP
13    }
14}
15
16world.dispose()  // siempre en dispose()

Crear cuerpos con KTX-Box2D#

 1// Cuerpo estático (plataforma)
 2val plataforma: Body = world.body {
 3    position.set(cx, cy)               // CENTRO del body
 4    // type = StaticBody por defecto en ktx-box2d
 5    box(halfWidth = w/2f, halfHeight = h/2f) {
 6        friction    = 0.6f
 7        restitution = 0f
 8        userData    = "suelo"          // identificador en ContactListener
 9    }
10}
11
12// Cuerpo dinámico (jugador)
13val jugador: Body = world.body(BodyDef.BodyType.DynamicBody) {
14    position.set(spawnX, spawnY)
15    fixedRotation = true               // evitar rotación al chocar con esquinas
16
17    // Fixture principal del cuerpo
18    box(halfWidth = 0.4f, halfHeight = 0.55f) {
19        density     = 1f
20        friction    = 0.1f
21        restitution = 0f
22        userData    = "jugador"
23    }
24
25    // Sensor de pies (detecta suelo sin respuesta física)
26    box(halfWidth = 0.35f, halfHeight = 0.1f,
27        position   = Vector2(0f, -0.65f)) {  // justo debajo del cuerpo
28        isSensor = true
29        userData = "pies_jugador"
30    }
31}
32
33// Sensor circular (moneda)
34val moneda: Body = world.body {
35    position.set(x, y)
36    circle(radius = 0.3f) {
37        isSensor = true
38        userData = "moneda"
39    }
40}

Aplicar movimiento al jugador (patrón plataformas)#

 1// Movimiento horizontal: impulso para respuesta inmediata
 2fun moverHorizontal(body: Body, direccion: Float, velocidadMax: Float) {
 3    val velActual  = body.linearVelocity.x
 4    val velDeseada = direccion * velocidadMax
 5    val impulso    = body.mass * (velDeseada - velActual)
 6    body.applyLinearImpulse(impulso, 0f,
 7        body.worldCenter.x, body.worldCenter.y, wake = true)
 8}
 9
10// Salto: impulso vertical instantáneo
11fun saltar(body: Body, fuerzaSalto: Float) {
12    val impulso = body.mass * fuerzaSalto
13    body.applyLinearImpulse(0f, impulso,
14        body.worldCenter.x, body.worldCenter.y, wake = true)
15}
16
17// Limitar velocidad vertical máxima (evitar velocidades infinitas en caída)
18val maxCaida = -20f
19if (body.linearVelocity.y < maxCaida) {
20    body.setLinearVelocity(body.linearVelocity.x, maxCaida)
21}

ContactListener#

 1world.setContactListener(object : ContactListener {
 2    override fun beginContact(contact: Contact) {
 3        val datA = contact.fixtureA.userData as? String
 4        val datB = contact.fixtureB.userData as? String
 5
 6        // ¿Pies del jugador tocan suelo?
 7        val piesEnSuelo = (datA == "pies_jugador" && datB == "suelo") ||
 8                          (datB == "pies_jugador" && datA == "suelo")
 9        if (piesEnSuelo) jugadorEnSuelo = true
10
11        // ¿Jugador recoge moneda?
12        if (datA == "jugador" && datB == "moneda")
13            accionesPendientes += { world.destroyBody(contact.fixtureB.body) }
14        if (datB == "jugador" && datA == "moneda")
15            accionesPendientes += { world.destroyBody(contact.fixtureA.body) }
16    }
17
18    override fun endContact(contact: Contact) {
19        val datA = contact.fixtureA.userData as? String
20        val datB = contact.fixtureB.userData as? String
21        if ((datA == "pies_jugador" && datB == "suelo") ||
22            (datB == "pies_jugador" && datA == "suelo")) {
23            jugadorEnSuelo = false
24        }
25    }
26
27    // OBLIGATORIOS aunque estén vacíos:
28    override fun preSolve(contact: Contact, oldManifold: Manifold) {}
29    override fun postSolve(contact: Contact, impulse: ContactImpulse) {}
30})
31
32// Ejecutar acciones diferidas DESPUÉS de world.step()
33accionesPendientes.forEach { it() }
34accionesPendientes.clear()

Box2DDebugRenderer#

1val debugRenderer = Box2DDebugRenderer()
2
3// En render(), después de dibujar el juego
4if (modoDebug) {
5    debugRenderer.render(world, camera.combined)
6}
7
8debugRenderer.dispose()   // en dispose()

10. TiledMap — referencia rápida#

Cargar mapa#

1// Con AssetManager (recomendado)
2assets.setLoader(TiledMap::class.java, TmxMapLoader(InternalFileHandleResolver()))
3assets.load("mapas/nivel1.tmx", TiledMap::class.java)
4// ...
5val map: TiledMap = assets.get("mapas/nivel1.tmx", TiledMap::class.java)
6
7// Sin AssetManager
8val map: TiledMap = TmxMapLoader().load("mapas/nivel1.tmx")

Renderizar mapa#

1// El unitScale debe ser 1f / tamañoTileEnPíxeles
2val renderer = OrthogonalTiledMapRenderer(map, 1f / 32f, batch)
3
4// En render()
5renderer.setView(camera)
6renderer.render()                      // todas las capas visibles
7renderer.render(intArrayOf(0, 1, 3))   // capas específicas por índice
8
9renderer.dispose()   // dispose() en la pantalla, NO en el mapa (el mapa lo gestiona AssetManager)

Extraer objetos y crear bodies Box2D#

 1val unitScale = 1f / 32f
 2
 3// Capa de rectángulos → bodies estáticos de suelo
 4val capaColisiones = map.layers.get("colisiones")
 5for (obj in capaColisiones.objects.getByType(RectangleMapObject::class.java)) {
 6    val r = obj.rectangle
 7    val x = r.x * unitScale;  val y = r.y * unitScale
 8    val w = r.width * unitScale;  val h = r.height * unitScale
 9    world.body {
10        position.set(x + w/2f, y + h/2f)
11        box(halfWidth = w/2f, halfHeight = h/2f) {
12            friction = 0.6f; userData = "suelo"
13        }
14    }
15}
16
17// Extraer posiciones de entidades por nombre
18val capaEntidades = map.layers.get("entidades")
19capaEntidades.objects.getByType(RectangleMapObject::class.java)
20    .filter { it.name == "moneda" }
21    .map    { Vector2(it.rectangle.x * unitScale, it.rectangle.y * unitScale) }
22    .forEach { pos -> crearMoneda(pos) }

Propiedades personalizadas (con ktx-tiled)#

1// En un objeto de la capa
2val velocidad: Float  = objeto.property("velocidad", defaultValue = 2f)
3val esDanino: Boolean = objeto.property("danino",    defaultValue = false)
4val tipo: String      = objeto.property("tipo",      defaultValue = "normal")

11. Partículas — referencia rápida#

 1// Cargar efecto (en create() o show(), no en render())
 2val efecto = ParticleEffect()
 3efecto.load(
 4    Gdx.files.internal("particles/polvo_salto.p"),
 5    Gdx.files.internal("particles")   // carpeta de la imagen de partícula
 6)
 7efecto.scaleEffect(1f / 32f)   // ajustar escala al mundo del juego
 8
 9// Posicionar y activar
10efecto.setPosition(x, y)
11efecto.start()
12
13// En render(), DENTRO de batch.use {}
14efecto.draw(batch, delta)   // actualiza Y dibuja en un solo paso
15
16// Estado
17efecto.isComplete    // true cuando todas las partículas han muerto
18efecto.isStarted     // true si está activo
19efecto.reset()       // reiniciar para reutilizar
20
21efecto.dispose()     // en dispose() de la pantalla

12. Fuentes — BitmapFont y FreeType#

 1// ── BitmapFont (fuente por defecto incluida en LibGDX) ───────────────────
 2
 3val fuente = BitmapFont()           // Arial 15px
 4fuente.color = Color.WHITE
 5fuente.data.setScale(1.5f)         // escala (permanente; resetear después si es necesario)
 6
 7// Dentro de batch.use {}
 8fuente.draw(batch, "Texto", x, y)
 9
10// GlyphLayout: para medir dimensiones antes de dibujar (centrar texto)
11val layout = GlyphLayout(fuente, "¡GAME OVER!")
12val textX  = (WORLD_W - layout.width) / 2f
13fuente.draw(batch, layout, textX, y)
14
15fuente.dispose()   // en dispose()
16
17// ── FreeType (fuentes TTF personalizadas) ────────────────────────────────
18
19val generator = FreeTypeFontGenerator(Gdx.files.internal("fuentes/roboto.ttf"))
20val params = FreeTypeFontGenerator.FreeTypeFontParameter().apply {
21    size        = 32
22    color       = Color.WHITE
23    borderWidth = 1f
24    borderColor = Color.BLACK
25    characters  = FreeTypeFontGenerator.DEFAULT_CHARS + "áéíóúÁÉÍÓÚñÑ¡¿"
26}
27val fuenteTTF: BitmapFont = generator.generateFont(params)
28generator.dispose()     // liberar el generador (la fuente resultante sigue siendo válida)
29// fuenteTTF.dispose() en dispose() de la pantalla

13. Scene2D — Stage y Table para HUD#

 1// Stage con viewport propio (independiente de la cámara del juego)
 2val stage = Stage(ScreenViewport(), batch)
 3
 4// Conectar al InputMultiplexer si se necesita entrada en el HUD
 5Gdx.input.inputProcessor = InputMultiplexer(stage, gameInput)
 6
 7// Table: layout declarativo
 8val tabla = Table()
 9tabla.top().setFillParent(true)     // anclar al borde superior, tamaño de pantalla
10
11val estilo = Label.LabelStyle(fuente, Color.WHITE)
12val labelMonedas = Label("Monedas: 0", estilo)
13val labelVidas   = Label("Vidas: 3",   estilo)
14
15tabla.add(labelMonedas).expandX().left().pad(10f)
16tabla.add(labelVidas).expandX().right().pad(10f)
17
18stage.addActor(tabla)
19
20// Actualizar texto de las etiquetas
21labelMonedas.setText("Monedas: ${game.monedasRecogidas}")
22
23// En render() — DESPUÉS de dibujar el juego
24stage.act(delta)
25stage.draw()
26
27// En resize()
28stage.viewport.update(width, height, true)
29
30stage.dispose()   // en dispose()

14. Launcher Android — AndroidManifest.xml#

 1<!-- AndroidManifest.xml -->
 2<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 3
 4    <application
 5        android:icon="@drawable/ic_launcher"
 6        android:label="@string/app_name">
 7
 8        <activity
 9            android:name=".android.AndroidLauncher"
10            android:label="@string/app_name"
11            android:screenOrientation="landscape"
12            android:configChanges="keyboard|keyboardHidden|navigation|orientation|screenSize|screenLayout"
13            android:exported="true">
14            <intent-filter>
15                <action android:name="android.intent.action.MAIN" />
16                <category android:name="android.intent.category.LAUNCHER" />
17            </intent-filter>
18        </activity>
19
20    </application>
21</manifest>

 1// AndroidLauncher.kt
 2class AndroidLauncher : AndroidApplication() {
 3    override fun onCreate(savedInstanceState: Bundle?) {
 4        super.onCreate(savedInstanceState)
 5        val config = AndroidApplicationConfiguration().apply {
 6            useAccelerometer = false
 7            useCompass       = false
 8            useGyroscope     = false
 9            useWakelock      = true          // evitar apagado de pantalla
10            useImmersiveMode = true          // pantalla completa
11        }
12        initialize(KotlinPlatformGame(), config)
13    }
14}

15. Tabla de errores comunes y soluciones#

Error	Causa	Solución
`OpenGLException` al arrancar	`Texture` / `SpriteBatch` creados antes de `create()`	Moverlos al cuerpo de `create()` o usar `lateinit`
`IllegalStateException: called begin()`	`begin()` sin `end()` anterior, o SpriteBatch + ShapeRenderer activos a la vez	Asegurarse de que cada `begin()` tiene su `end()` antes del siguiente
Jugador rota al golpear esquinas	`fixedRotation = false` (valor por defecto)	Poner `fixedRotation = true` en el BodyDef del jugador
Sensor de pies nunca detecta suelo	La fixture sensor tiene el mismo `userData` que la principal	Asignar `userData = "pies_jugador"` solo al sensor, `"jugador"` al cuerpo
Crash `Box2D: assertion` al destruir body	`destroyBody()` llamado dentro de `ContactListener`	Encolar la destrucción en una lista; ejecutar después de `world.step()`
Mapa y bodies Box2D con escala diferente	`unitScale` distinto en `MapLoader` y `OrthogonalTiledMapRenderer`	Usar la misma constante `UNIT_SCALE = 1f / 32f` en ambos
Mapa no se ve / pantalla negra	`mapRenderer.setView(camera)` no llamado antes de `render()`	Llamar a `setView()` en cada fotograma
El atlas no carga	El archivo `.atlas` o `.png` no está en `android/assets/`	Verificar ruta y copiar ambos archivos al directorio correcto
Fugas de memoria en GPU	Assets no liberados con `dispose()`	Revisar que todos los `Texture`, `SpriteBatch`, `ShapeRenderer`, `Sound`, `TiledMap` y `ParticleEffect` tienen su `dispose()`
Movimiento dependiente de framerate	Velocidades fijas sin multiplicar por `delta`	Siempre: `posicion += velocidad * delta`
Coordenadas de toque incorrectas	Usar `Gdx.input.x/y` directamente sin `unproject`	`viewport.unproject(Vector3(x.toFloat(), y.toFloat(), 0f))`
Partículas demasiado grandes	`ParticleEffect` creado en píxeles; mundo en unidades	`efecto.scaleEffect(1f / 32f)` después de cargar
Música no se pausa al minimizar	`pause()` de Screen no gestiona la música	Sobreescribir `pause()` y llamar a `musica.pause()`

16. Checklist de entrega del proyecto#

Antes de presentar el proyecto, verificar que: