Knight’s Quest: Desarrollo de un plataformas 3D en Godot

Knight’s Quest es un videojuego de plataformas en 3D desarrollado en Godot Engine 4.x. El protagonista es un caballero que debe recolectar monedas esparcidas por un nivel flotante, inspirándose en mecánicas clásicas de juegos como Super Mario 3D. Para los modelos tridimensionales se utilizan paquetes de assets de KayKit, incluyendo el personaje, las monedas, las plataformas y los elementos decorativos. Todo el trabajo de cinemática, sistemas de cámara, iluminación y lógica de juego se implementa de forma manual, sin recurrir a plugins externos o sistemas automatizados.

El presente documento detalla el proceso completo de desarrollo, organizado en fases secuenciales. Cada fase incluye los pasos técnicos ejecutados, las decisiones de diseño adoptadas y las referencias a las figuras que ilustran el estado del proyecto en cada etapa.

---

Fase 1: Fundamentos y configuración del entorno

1.1 Instalación de Godot Engine y creación del proyecto

El primer paso consiste en descargar Godot Engine 4.x desde el sitio web oficial. Se selecciona la versión estable para el sistema operativo de desarrollo (Windows 10/11). Una vez descargado, se extrae el contenido en una carpeta local y se ejecuta el archivo ejecutable.

Dentro del administrador de proyectos de Godot, se crea un nuevo proyecto con las siguientes características:

• Nombre del proyecto: Knight’s Quest
• Ruta de almacenamiento: C:/GodotProjects/KnightsQuest
• Renderizador: Compatibility (para mayor compatibilidad) o Forward+ (para efectos visuales avanzados)
• Template: 3D

Tras la creación, el proyecto se abre y se muestra la escena vacía predeterminada, que contiene una cámara (Camera3D) y una luz (DirectionalLight3D).

Figura 1. Ventana principal de Godot Engine con el proyecto “Knight’s Quest” recién creado.

---

1.2 Configuración del suelo con CSGBox3D

Para que el caballero tenga una superficie sobre la cual desplazarse, se construye un suelo utilizando un nodo CSGBox3D. Este nodo pertenece a la familia CSG (Constructive Solid Geometry), que permite modelar geometría básica directamente dentro del editor.

Procedimiento:

1. En el árbol de escenas, se hace clic en el icono de “más” (Añadir nodo).
2. Se busca y selecciona CSGBox3D.
3. Se renombra el nodo como Suelo.
4. En el inspector, se ajusta la propiedad Size a (20, 1, 20) para crear una plataforma ancha y plana.
5. Se activa la opción Use Collision para que el suelo genere automáticamente una forma de colisión.

Figura 2. Nodo CSGBox3D configurado como suelo, con dimensiones 20x1x20.

---

1.3 Navegación en la vista 3D

Para facilitar la colocación de objetos, se domina el sistema de navegación de la vista 3D de Godot:

• Rotar la vista: Manteniendo presionado el botón derecho del mouse y arrastrando.
• Pan (desplazamiento lateral): Manteniendo presionado el botón central del mouse y arrastrando.
• Zoom: Usando la rueda del mouse.
• Movimiento con teclado: Manteniendo presionado el botón derecho del mouse y usando las teclas WASD para desplazarse por la escena.

Esta navegación permite inspeccionar el suelo desde cualquier ángulo y preparar el escenario para recibir al personaje.

Figura 3. Vista 3D del editor mostrando el suelo desde una perspectiva angular.

---

1.4 Adición del WorldEnvironment

La escena 3D por defecto carece de iluminación ambiental y cielo, lo que resulta en una apariencia plana y oscura. Para corregir esto, se añade un nodo WorldEnvironment.

Procedimiento:

1. Se añade un nodo WorldEnvironment al árbol de escenas.
2. En el inspector, se crea un nuevo recurso Environment haciendo clic en “Nuevo Environment”.
3. Se configura la propiedad Background:
   • Se selecciona Sky como modo de fondo.
   • Se crea un nuevo recurso Sky.
   • Se asigna un PanoramaSkyMaterial o ProceduralSkyMaterial.
4. Se ajusta la propiedad Ambient Light:
   • Color: Blanco suave (0.8, 0.8, 0.8).
   • Energy: 0.7 para una iluminación global tenue pero suficiente.

Este entorno mejora drásticamente la visibilidad de los objetos y prepara la escena para recibir luces más detalladas.

Figura 4. Inspector del nodo WorldEnvironment mostrando la configuración de Sky y Ambient Light.

Para la implementacion final, se hizo uso de la imagen enviroment, la cual es una imagen pensada para cambiar todo el entorno del juego, usa una separacion de lo se vera en 3d en el suelo y en el cielo.

Figura 5. Imagen enviroment usada en el juego.

---

Fase 2: Programación básica y movimiento de objetos para Knight’s Quest

2.1 Creación de un script simple y función _ready()

Para verificar que el sistema de scripting funciona correctamente, se añade un script a un nodo temporal. Se utiliza la función _ready(), que se ejecuta automáticamente una sola vez cuando el nodo y todos sus hijos han sido completamente cargados en el árbol de escenas.

Código de prueba:

extends Node3D

func _ready():
    print("Sistema de script funcionando correctamente")

Al ejecutar la escena (F6), el mensaje aparece en la consola de salida, confirmando que el entorno de programación está listo.

Figura 6. Consola de salida de Godot mostrando el mensaje de verificación.

---

2.2 Manipulación manual de la posición (transformaciones)

El movimiento de objetos en Godot se realiza modificando la propiedad position de cualquier nodo heredado de Node3D. Esta propiedad es un Vector3 con componentes (x, y, z).

Para demostrarlo, se selecciona el CSGBox3D del suelo y se escribe un pequeño script que lo desplaza en el eje X:

Código de ejemplo:

extends CSGBox3D

var velocidad = 2.0

func _process(delta):
    position.x += velocidad * delta

El uso de delta (el tiempo transcurrido entre frames) asegura que el movimiento sea fluido e independiente de la tasa de frames. El operador += incrementa el valor actual de position.x.

Figura 7. Script aplicado al suelo mostrando la lógica de movimiento con operador +=.

2.3 Implementación de física con RigidBody3D

Para introducir físicas realistas, se crea un objeto independiente usando RigidBody3D. A diferencia de otros cuerpos, este reacciona automáticamente a la gravedad, colisiones y fuerzas.

Procedimiento:

1. Se añade un nodo RigidBody3D renombrado como CajaPrueba.
2. Se añade un nodo hijo CollisionShape3D con una forma BoxShape3D del tamaño adecuado.
3. Se añade un nodo hijo MeshInstance3D con un BoxMesh para representación visual.
4. En el inspector del RigidBody3D, se ajustan:
   • Mass: 1.0
   • Friction: 0.5
   • Bounce: 0.3

Al ejecutar la escena, la caja cae por gravedad, rebota ligeramente y se detiene sobre el suelo. Este comportamiento demuestra el motor de físicas integrado.

Figura 8. Jerarquía de nodos del RigidBody3D con CollisionShape3D y MeshInstance3D.

Fase 3: Construcción del personaje jugable (caballero)

3.1 Estructura del CharacterBody3D formando Knight’s Quest

El caballero se implementa mediante un nodo CharacterBody3D, que proporciona un control preciso sobre el movimiento sin estar completamente gobernado por la física como un RigidBody3D.

Jerarquía de nodos:

• Caballero (CharacterBody3D)
  • CollisionShape3D (forma de CapsuleShape3D)
  • MeshInstance3D (modelo 3D importado desde KayKit)
  • SpringArm3D (para la cámara en tercera persona)
    • Camera3D

La CapsuleShape3D se elige sobre BoxShape3D porque se aproxima mejor a la silueta de un personaje humanoide, facilitando el paso por espacios angostos.

Figura 9. Árbol de nodos del personaje Caballero mostrando la estructura completa.

---

3.2 Importación de assets desde KayKit

Para el modelo visual del caballero, las monedas y los elementos decorativos se utilizan los paquetes de assets gratuitos de KayKit, disponibles en el sitio oficial de KayKit (kaykit.games). Se descargan los paquetes “Character Pack”, “Platformer Pack” y “Coins Pack” en formato .glb (glTF).

Procedimiento de importación:

1. En el panel FileSystem de Godot, se crea la carpeta assets/models/.
2. Se arrastran los archivos .glb desde el explorador del sistema a la carpeta.
3. Godot procesa automáticamente los archivos, generando los recursos internos.
4. Se selecciona el modelo del caballero y, en el inspector, se habilita Import As Skeleton para mantener las animaciones (si las hubiera).

El modelo del caballero se asigna a la MeshInstance3D hija del CharacterBody3D.

Figura 10. Panel FileSystem mostrando los assets de KayKit importados.

---

3.3 Configuración del movimiento manual (cinemática)

El movimiento del caballero se implementa manualmente mediante código GDScript, sin usar plugins de cinemática predefinidos. El script se adjunta al nodo Caballero.

Script completo de movimiento:

class_name Player
extends CharacterBody3D

const SPEED = 6.0
const JUMP_VELOCITY = 7
@export var sens_horizontal: float = 0.003
@export var sens_vertical: float = 0.003

# Animaciones
@onready var animation_player: AnimationPlayer = $Knight/AnimationPlayer
@onready var knight: Node3D = $Knight

# Cámara
@onready var camera_pivot: Node3D = $pivot
@onready var camera: Camera3D = $pivot/Camera3D

var max_up := deg_to_rad(60)
var min_down := deg_to_rad(-60)
var pitch := 0.0
var camera_yaw: float = 0.0

# Estado de animación
var current_animation: String = ""
var is_jumping: bool = false

func _ready() -> void:
	Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
	
	if not camera:
		camera = $pivot2/Camera3D
		camera_pivot = $pivot2
	
	if camera:
		camera.current = true
		if camera == $pivot/Camera3D and $pivot2/Camera3D:
			$pivot2/Camera3D.current = false
		elif camera == $pivot2/Camera3D and $pivot/Camera3D:
			$pivot/Camera3D.current = false
	
	if not animation_player:
		print("Error: No se encontró AnimationPlayer en Knight")
	else:
		play_animation("Player/Idle_A")

func _input(event):
	if event is InputEventMouseMotion and Input.mouse_mode == Input.MOUSE_MODE_CAPTURED:
		camera_yaw -= event.relative.x * sens_horizontal
		pitch -= event.relative.y * sens_vertical
		pitch = clamp(pitch, min_down, max_up)
		
		camera_pivot.rotation = Vector3(pitch, camera_yaw, 0.0)

func _physics_process(delta: float) -> void:
	# Gravedad
	if not is_on_floor():
		velocity += get_gravity() * delta
		
		if velocity.y > 0 and not is_jumping:
			play_animation("Player/Jump_Start")
			is_jumping = true
		elif velocity.y <= 0 and is_jumping:
			play_animation("Player/Jump_Full_Long")
	else:
		if is_jumping:
			play_animation("Player/Jump_Land")
			is_jumping = false
			await get_tree().create_timer(0.2).timeout
			if is_on_floor():
				update_movement_animation()

	# Salto
	if Input.is_action_just_pressed("ui_accept") and is_on_floor():
		velocity.y = JUMP_VELOCITY
		play_animation("Player/Jump_Start")
		is_jumping = true

	# Movimiento relativo a la cámara
	var input_dir := Input.get_vector("izquierda", "derecha", "adelante", "atras")
	
	var cam_basis = Basis(Vector3.UP, camera_yaw)
	var direction := (cam_basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()
	
	if direction != Vector3.ZERO:
		velocity.x = direction.x * SPEED
		velocity.z = direction.z * SPEED
		
		var target_angle = atan2(direction.x, direction.z)
		knight.global_rotation.y = lerp_angle(knight.global_rotation.y, target_angle, 0.2)
	else:
		velocity.x = move_toward(velocity.x, 0, SPEED)
		velocity.z = move_toward(velocity.z, 0, SPEED)
	
	# Actualizar animación
	if is_on_floor() and not is_jumping:
		update_movement_animation()
	
	move_and_slide()

func update_movement_animation():
	var is_moving = abs(velocity.x) > 0.1 or abs(velocity.z) > 0.1
	
	if is_moving:
		if Input.is_action_pressed("sprint"):
			play_animation("Player/Running_B")
		else:
			play_animation("Player/Walking_B")
	else:
		play_animation("Player/Idle_A")

func play_animation(anim_name: String):
	if not animation_player:
		return
	
	if animation_player.has_animation(anim_name):
		if current_animation == anim_name:
			return
		current_animation = anim_name
		animation_player.play(anim_name)
	else:
		var simple_name = anim_name.replace("Player/", "")
		if animation_player.has_animation(simple_name):
			if current_animation == simple_name:
				return
			current_animation = simple_name
			animation_player.play(simple_name)

Se crean acciones de entrada personalizadas (move_left, move_right, move_forward, move_back, jump) en el Input Map (Editor de Proyecto > Controles), asignando teclas WASD y Espacio.

Figura 11. Editor de Input Map mostrando las acciones personalizadas para el caballero.

---

Fase 4: Diseño del nivel con CSG y StaticBody3D en Knight’s Quest

4.1 Creación de plataformas flotantes

El nivel de Knight’s Quest se compone de varias plataformas flotantes a distintas alturas. Para construirlas se utilizan nodos CSGBox3D y StaticBody3D.

Procedimiento:

1. Se añade un nodo StaticBody3D como raíz de cada plataforma.
2. Se añade un hijo CollisionShape3D con forma BoxShape3D.
3. Se añade un hijo CSGBox3D (o MeshInstance3D con modelo de KayKit) para la representación visual.
4. Se ajusta la posición y escala de cada plataforma manualmente usando las herramientas de transformación del editor.

Se crean cinco plataformas con las siguientes coordenadas (en unidades Godot):

Plataforma	Posición (x, y, z)	Escala (x, y, z)
Plataforma 1	(0, 0, 0)	(10, 1, 10)
Plataforma 2	(6, 3, 4)	(4, 1, 4)
Plataforma 3	(-5, 2, -3)	(5, 1, 5)
Plataforma 4	(3, 5, -2)	(3, 1, 3)
Plataforma 5	(-4, 4, 5)	(4, 1, 4)

Figura 12. Vista superior del nivel mostrando la disposición de las cinco plataformas flotantes.

4.2 Aplicación de texturas y materiales para integrar Knight’s Quest

Para mejorar la estética, se aplican materiales a cada plataforma usando StandardMaterial3D. Se crean recursos de material separados para madera, piedra y hierba, utilizando texturas provenientes de los assets de KayKit.

Procedimiento:

1. En el panel FileSystem, se crea una carpeta assets/materials/.
2. Se hace clic derecho > Nuevo Recurso > StandardMaterial3D.
3. En el inspector, se ajustan las propiedades:
   • Albedo > Texture: se carga una imagen de textura desde KayKit.
   • Metallic: 0.1 para materiales opacos.
   • Roughness: 0.8 para superficies rugosas.
4. Se arrastra el material creado a la propiedad Material del nodo MeshInstance3D o CSGBox3D.

Figura 13. Inspector del StandardMaterial3D mostrando la configuración de textura y rugosidad.

---

Fase 5: Iluminación manual y sistema de cámaras para mejor visualización en Knight’s Quest

5.1 Configuración de luces

La iluminación de Knight’s Quest se realiza enteramente de forma manual, sin usar iluminación precalculada (baked lighting) para mantener la flexibilidad.

Tipos de luces implementadas:

• DirectionalLight3D: Luz principal que simula el sol. Se rota para crear sombras diagonales. Propiedades:
  • Light Energy: 1.2
  • Color: Amarillo suave (1.0, 0.95, 0.85)
  • Shadow > Enabled: true, Bias: 0.1
• OmniLight3D: Luces puntuales colocadas cerca de las monedas para dar sensación de brillo. Propiedades:
  • Light Energy: 0.8
  • Color: Dorado (1.0, 0.8, 0.2)
  • Attenuation > Radius: 3.0

Todas las luces se posicionan manualmente usando las herramientas de transformación del editor.

Figura 14. Vista de la escena mostrando la posición de la DirectionalLight3D y las OmniLight3D cerca de las monedas.

5.2 Sistema de cámara en tercera persona (SpringArm3D)

La cámara sigue al caballero desde una perspectiva en tercera persona. Para ello se utiliza un nodo camera_pivot , que amortigua el movimiento y evita que la cámara atraviese paredes.

Jerarquía de la cámara:

Caballero (CharacterBody3D)
└── camera_pivot 
    └── Camera3D

Configuración del SpringArm3D:

• Length: 4.0 (distancia de la cámara al personaje)
• Margin: 0.01 (para evitar clipping)
• Collision Mask: activar capa 1 para detectar paredes

Configuración de la Camera3D:

• Current: true (cámara activa)
• FOV: 75.0 grados
• Near: 0.1, Far: 100.0

Adicionalmente, se implementa un script manual que permite rotar la cámara alrededor del caballero con el mouse:

class_name Player
extends CharacterBody3D

@export var sens_horizontal: float = 0.003
@export var sens_vertical: float = 0.003

# Cámara
@onready var camera_pivot: Node3D = $pivot
@onready var camera: Camera3D = $pivot/Camera3D

var max_up := deg_to_rad(60)
var min_down := deg_to_rad(-60)
var pitch := 0.0
var camera_yaw: float = 0.0

func _ready() -> void:
	Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
	
	if not camera:
		camera = $pivot2/Camera3D
		camera_pivot = $pivot2
	
	if camera:
		camera.current = true
		if camera == $pivot/Camera3D and $pivot2/Camera3D:
			$pivot2/Camera3D.current = false
		elif camera == $pivot2/Camera3D and $pivot/Camera3D:
			$pivot/Camera3D.current = false

func _input(event):
	if event is InputEventMouseMotion and Input.mouse_mode == Input.MOUSE_MODE_CAPTURED:
		camera_yaw -= event.relative.x * sens_horizontal
		pitch -= event.relative.y * sens_vertical
		pitch = clamp(pitch, min_down, max_up)
		
		# Asignar rotación completa de la cámara
		camera_pivot.rotation = Vector3(pitch, camera_yaw, 0.0)

Figura 15. Jerarquía de nodos mostrando el SpringArm3D y Camera3D como hijos del caballero.

---

Fase 6: Implementación de monedas y sistema de recolección de Knight’s Quest

6.1 Creación de la escena Moneda con Area3D

Cada moneda se implementa como una escena independiente, permitiendo instanciar múltiples copias en el nivel. La raíz es un nodo Area3D, que funciona como detector de superposición (trigger).

Jerarquía de la moneda:

• Moneda (Area3D)
  • CollisionShape3D (forma SphereShape3D con radio 0.4)
  • MeshInstance3D (modelo de moneda dorada desde KayKit)
  • AnimationPlayer (para rotación continua, opcional)

Propiedades del Area3D:

• Monitoring: true
• Monitorable: true
• Collision > Layer: capa 2
• Collision > Mask: capa 1 (para detectar al caballero)

Figura 16. Árbol de nodos de la escena Moneda con Area3D como raíz.

6.2 Señal body_entered y lógica de recolección

El sistema de recolección se basa en la señal body_entered del Area3D. Cuando el caballero entra en contacto con el área de la moneda, se ejecuta la lógica de suma de puntos y destrucción del objeto.

Script de la moneda:

extends Area3D

signal moneda_recolectada(valor: int)

@export var puntos: int = 10

func _ready() -> void:
    body_entered.connect(_on_body_entered)

func _on_body_entered(body: Node) -> void:
    if body is CharacterBody3D and body.name == "Caballero":
        moneda_recolectada.emit(puntos)
        queue_free()

En la escena principal, se conecta la señal moneda_recolectada a un método que actualiza la interfaz de usuario.

Figura 17. Conexión de señales en el editor mostrando la señal moneda_recolectada enlazada al script principal.

---

Fase 7: Interfaz de usuario y sistema de puntuación

7.1 Creación del HUD con CanvasLayer de Knight’s Quest

La interfaz de usuario se implementa mediante un nodo CanvasLayer, que garantiza que los elementos UI se dibujen por encima de la vista 3D.

Jerarquía del HUD:

• HUD (CanvasLayer)
  • Panel (fondo semitransparente)
    • Label (texto “Monedas: “)
    • Label (contador numérico)

Configuración de la etiqueta:

• Fuente: se carga una FontFile desde los assets de KayKit.
• Alineación: centro izquierda.
• Anchura y altura: ajustadas manualmente.

Figura 18. Vista del editor mostrando el HUD con el contador de monedas en la esquina superior izquierda.

7.2 Script de actualización de puntuación

En el script principal del nivel (nodo raíz), se declara una variable puntuacion_total y se actualiza cada vez que se recolecta una moneda.

Script del nivel:

extends Node3D

var puntuacion_total: int = 0

func _ready() -> void:
    actualizar_contador()

func _on_moneda_recolectada(puntos: int) -> void:
    puntuacion_total += puntos
    actualizar_contador()

func actualizar_contador() -> void:
    $HUD/Panel/Contador.text = str(puntuacion_total)

Cada moneda instanciada en el nivel conecta automáticamente su señal moneda_recolectada al método _on_moneda_recolectada del nivel.

Figura 19. Código del nivel principal mostrando la función de actualización del contador.

---

Fase 8: Programación orientada a objetos y recursos de Knight’s Quest

8.1 Creación de una clase personalizada para enemigos (extensible)

Para demostrar el uso de POO, se crea una clase base Enemigo que podría utilizarse en futuras versiones de Knight’s Quest.

Script de la clase:

class_name Enemigo
extends CharacterBody3D

@export var velocidad_movimiento: float = 2.0
@export var puntos_vida: int = 3

func recibir_dano(cantidad: int) -> void:
    puntos_vida -= cantidad
    if puntos_vida <= 0:
        morir()

func morir() -> void:
    queue_free()

Se registra la clase con class_name Enemigo, permitiendo instanciarla fácilmente desde cualquier escena.

Figura 20. Script de la clase Enemigo mostrando la palabra clave class_name y la función recibir_dano.

8.2 Uso de Resources para datos de configuración

Se crea un recurso personalizado (RecursoMoneda) para almacenar datos de configuración de las monedas, separando la lógica de los valores.

Script del recurso:

extends Resource
class_name RecursoMoneda

@export var valor_puntos: int = 10
@export var sonido_recoleccion: AudioStream
@export var color_emision: Color = Color.YELLOW

Luego, cada instancia de moneda carga un recurso diferente, permitiendo monedas con distintos valores o efectos sin modificar el código.

Figura 21. Inspector mostrando un RecursoMoneda configurado con valor 20 puntos y un sonido personalizado.

---

Fase 9: Integración final y pulido

9.1 Instanciación de monedas en el nivel de Knight’s Quest

Se colocan manualmente 11 monedas en el nivel, distribuidas sobre las plataformas flotantes. Para ello:

1. Se arrastra la escena Moneda.tscn desde el panel FileSystem a la vista 3D.
2. Se posiciona cada moneda usando las herramientas de transformación.
3. Se ajusta la altura de cada moneda (position.y) para que flote ligeramente sobre la plataforma.

Algunas monedas se colocan en posiciones que requieren saltos precisos, aumentando la dificultad del juego.

Figura 22. Vista del nivel final mostrando la disposición de las 11 monedas sobre las plataformas flotantes.

9.2 Ajuste de parámetros de Knight’s Quest

Se realizan pruebas de juego para equilibrar la experiencia:

• Velocidad del caballero: se prueba con valores entre 4.0 y 6.0. Se selecciona 5.5 como valor óptimo.
• Altura del salto: se prueba jump_speed entre 7.0 y 9.0. Se selecciona 8.0.
• Gravedad: se mantiene en 20.0 para una caída responsiva pero no demasiado rápida.

Todos estos parámetros se exponen como @export en el script del caballero, permitiendo ajustes sin recompilar.

Figura 23. Inspector del nodo Caballero mostrando las variables exportadas (speed, jump_speed, gravity).

9.3 Creacion de pantallas de inicio y fin

Se crean pantallas para el inicio y fin del juego:

Figura 24. Menu de inicio de juego.

Se crea el menu de inicio del juego el cual se conforma de 2 botones, jugar y salir, estos botones son accionados por el script de la escena, los cuales dan paso a la escena inicial o para salir del juego:

extends Control

func _on_button_pressed() -> void:
	get_tree().change_scene_to_file("res://ProyectoFinal/scenes/juego.tscn")


func _on_button_2_pressed() -> void:
	get_tree().quit()

Figura 25. Escena final del juego.

La escena final del juego, muestra un mensaje de agradecimiento y proximas actualizaciones.

Conclusiones

El desarrollo de Knight’s Quest demuestra que Godot Engine, combinado con assets de KayKit y un trabajo manual cuidadoso en cinemática, iluminación y lógica, permite crear un plataformas 3D completo y funcional. Los aspectos técnicos más relevantes son:

1. Arquitectura modular: El uso de escenas independientes (caballero, moneda, plataformas) facilita la reutilización y el mantenimiento.
2. Control manual de cinemática: El CharacterBody3D con script personalizado ofrece un control total sobre el movimiento, esencial para juegos de plataformas precisos.
3. Detección mediante áreas: Las Area3D y las señales (body_entered) proporcionan un sistema limpio y desacoplado para la recolección de objetos.
4. Iluminación artesanal: Colocar y ajustar manualmente cada luz (DirectionalLight3D, OmniLight3D) permite crear atmósferas personalizadas sin depender de sistemas automatizados.
5. Escalabilidad mediante POO y Resources: Las clases personalizadas y los recursos permiten expandir el juego (añadir enemigos, power-ups, niveles) sin reescribir el código existente.

El resultado final es un juego jugable donde el caballero recorre un nivel flotante, salta entre plataformas y recolecta monedas, con una cámara en tercera persona que sigue al personaje y un contador en pantalla que muestra el progreso. Knight’s Quest sirve como base sólida para proyectos más ambiciosos en Godot.

Video muestra

Referencias

Kay Lousberg. (s.f.). KayKit - Character Pack : Adventurers [Modelos 3D y animaciones]. Itch.io. Recuperado el 21 de mayo de 2026, de https://kaylousberg.itch.io/kaykit-adventurers

Godot Engine. (s.f.). *Documentación de Godot Engine - Versión estable (4.6)*. Recuperado el 21 de mayo de 2026, de https://docs.godotengine.org/en/stable/

Gdquest. (2025, 3 de diciembre). Aprende Godot de CERO a PRO (en 5 horas) [Video]. YouTube. https://www.youtube.com/watch?v=0si7UgBegDk&t=3545s

Créditos

Autor: Valentina Rodriguez Casallas – Luis Esteban Riaño Montiel

Editor: Mg. Ing. Carlos Iván Pinzón Romero

Código: UCMV-09

Universidad: Universidad Central