Entorno de Unreal Engine y flujo de trabajo con Blueprints

Configurar un proyecto orientado a gameplay

Elegir una plantilla adecuada

Para empezar con Blueprints enfocados a lógica de juego, conviene partir de una plantilla que ya incluya un personaje controlable, cámara y entradas configuradas. En el navegador de proyectos, las plantillas más útiles para principiantes son:

• First Person: ideal para probar interacción directa (mirar, disparar, recoger).
• Third Person: ideal para movimiento y animación de personaje, cámara orbitando y pruebas de colisiones.
• Top Down: útil para clic para mover y juegos de estrategia/ARPG.

Recomendación práctica: si tu objetivo es aprender flujo de trabajo general de gameplay, Third Person suele ser la más versátil.

Ajustes esenciales del proyecto (rápidos y prácticos)

Antes de crear Blueprints, revisa estos puntos para evitar fricción durante las pruebas:

• Maps & Modes: define el mapa por defecto y el GameMode del proyecto para que al presionar Play siempre cargue lo esperado.
• Input: confirma que existen acciones/ejes (o mapeos) para moverte y mirar. Si usas una plantilla, normalmente ya vienen listos.
• Play Settings: prueba “Selected Viewport” para iterar rápido y “New Editor Window” si necesitas ver el juego en una ventana separada.
• Auto Save: útil para principiantes; mantenlo activo, pero acostúmbrate a guardar manualmente antes de cambios grandes.

Objetivo: que tu ciclo sea editar → compilar → guardar → Play/Simulate → ajustar sin sorpresas.

Ventanas clave del editor y cómo se relacionan con un nivel

Viewport (la escena)

El Viewport es donde navegas el nivel y colocas actores. Aquí verás el resultado espacial de tus cambios: transformaciones, colisiones, iluminación y composición. Para un flujo eficiente, acostúmbrate a alternar entre mover/rotar/escalar y a usar el foco sobre el objeto seleccionado.

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

World Outliner (la lista de actores del nivel)

El World Outliner muestra todos los Actors presentes en el nivel actual. Es clave para:

• Seleccionar rápidamente un actor sin buscarlo visualmente.
• Ver jerarquías (por ejemplo, actores “adjuntos” a otros).
• Renombrar actores para mantener orden (por ejemplo: BP_Rotator_01).

Details (propiedades del actor seleccionado)

El panel Details cambia según lo que selecciones. Es el centro de edición de:

• Transform (Location/Rotation/Scale).
• Propiedades expuestas por Blueprints (variables marcadas como editables).
• Componentes del actor (si seleccionas un componente, verás sus propiedades específicas).

Idea clave: un buen Blueprint expone en Details lo que el diseñador necesita ajustar sin abrir el gráfico.

Content Browser (los assets del proyecto)

El Content Browser es tu biblioteca: Blueprints, materiales, texturas, sonidos, UI, etc. Un flujo sano implica:

• Crear carpetas claras desde el inicio.
• Nombrar assets con prefijos (por ejemplo, BP_, M_, WBP_).
• Evitar dejar assets sueltos en la raíz.

Cómo se organiza un nivel (modelo mental)

Un nivel (mapa) contiene instancias de actores colocadas en el mundo. Piensa en tres capas:

• Geometría/escenario: mallas estáticas, suelos, paredes.
• Gameplay: triggers, pickups, puertas, spawners, enemigos.
• Presentación: luces, post-proceso, sonido ambiental, UI (aunque la UI suele vivir fuera del nivel y se instancia en runtime).

Cuando presionas Play, Unreal crea una sesión de juego donde esos actores comienzan a ejecutar su lógica (eventos como BeginPlay, Tick, colisiones, etc.).

Qué es un Blueprint y tipos principales

Un Blueprint es un asset que permite definir comportamiento y estructura usando un sistema visual (nodos) y componentes. En la práctica, un Blueprint puede:

• Representar un objeto del mundo (un actor con malla y colisión).
• Controlar un personaje jugable o IA.
• Encapsular funcionalidad reutilizable como componente.
• Definir lógica específica de un nivel.
• Construir interfaces de usuario.

Actor Blueprint

Úsalo cuando necesites un objeto “colocable” en el mundo: una puerta, un interruptor, un pickup, una plataforma móvil. Suele incluir componentes (Static Mesh, Box Collision, Audio, etc.) y eventos (BeginPlay, overlap, interacción).

Pawn / Character Blueprint

Pawn representa una entidad que puede ser poseída por un controlador (jugador o IA). Character es un tipo de Pawn con movimiento de personaje ya resuelto (cápsula, CharacterMovement, saltar, caminar). Úsalos cuando:

• Necesites control directo del jugador (Character típico).
• Necesites una entidad poseíble no humanoide (Pawn para drones, cámaras, vehículos simples).

Component Blueprint

Un Blueprint Component encapsula lógica reutilizable para “pegarla” a distintos actores. Úsalo cuando una funcionalidad se repite en varios objetos, por ejemplo:

• Un componente de “Salud” para enemigos y jugador.
• Un componente de “Interacción” para objetos interactuables.
• Un componente de “Rotación constante” para props decorativos.

Regla práctica: si te encuentras copiando el mismo gráfico en varios actores, considera un componente.

Level Blueprint

El Level Blueprint es un gráfico asociado a un mapa específico. Úsalo para lógica puntual del nivel, como:

• Secuencias de eventos al entrar al nivel.
• Activar una cinemática al cumplir una condición.
• Prototipos rápidos ligados a actores concretos del mapa.

Evita meter aquí sistemas reutilizables; para eso, mejor Actor/Component Blueprints.

Widget Blueprint (UI)

Un Widget Blueprint define interfaces (HUD, menús, inventario). Úsalo cuando necesites:

• Mostrar información (vida, munición, objetivos).
• Crear pantallas de menú y botones.
• Interfaces de interacción (prompts, diálogos).

Normalmente se crea el widget y se instancia desde el Player Controller, HUD o el propio Character, según tu arquitectura.

Práctica guiada: crear un Actor Blueprint simple y probarlo

Objetivo: crear un actor que puedas colocar en el nivel, ajustar desde Details y verificar cambios en Play/Simulate. Harás un “prop” con una malla y una rotación configurable.

Paso 1: crear el Blueprint

• En el Content Browser, crea una carpeta temporal para la práctica (por ejemplo Blueprints/Practice).
• Clic derecho → Blueprint Class.
• Selecciona Actor.
• Nómbralo BP_SimpleRotator.

Paso 2: agregar componentes (estructura del actor)

• Abre BP_SimpleRotator.
• En el panel de componentes, agrega un Static Mesh (por ejemplo SM_Mesh).
• En el Static Mesh, asigna una malla simple (un cubo o cualquier mesh disponible en tu proyecto).

Esto define “qué es” el actor visualmente.

Paso 3: crear variables editables (para el panel Details)

Crea variables para controlar el comportamiento sin tocar el gráfico:

• Variable RotationSpeed (tipo float), valor por defecto 45.0.
• Marca la variable como Instance Editable (editable por instancia) para que aparezca en Details cuando coloques el actor en el nivel.

Opcional útil: agrupa variables con una categoría (por ejemplo “Rotator”).

Paso 4: implementar la rotación en el Event Graph

En el Event Graph, crea una rotación continua basada en el tiempo. Una lógica típica es usar Tick y Delta Seconds para que sea independiente del framerate.

Event Tick (Delta Seconds) → AddActorLocalRotation(0, RotationSpeed * DeltaSeconds, 0)

Notas prácticas:

• Si rotas en Yaw, el actor girará sobre el eje vertical.
• Multiplicar por Delta Seconds hace que RotationSpeed se interprete como “grados por segundo”.
• Compila y guarda el Blueprint.

Paso 5: colocar el Blueprint en el nivel

• Arrastra BP_SimpleRotator desde el Content Browser al Viewport.
• Verifica que aparece en el World Outliner.
• Renombra la instancia si vas a crear varias (por ejemplo BP_SimpleRotator_A).

Paso 6: ajustar propiedades desde Details (por instancia)

• Selecciona la instancia en el nivel.
• En Details, encuentra RotationSpeed.
• Cambia el valor (por ejemplo 10, 90, 180) y observa cómo afecta la rotación al ejecutar.

Prueba rápida: duplica el actor (Ctrl+D) y asigna un RotationSpeed distinto a cada instancia para confirmar que la variable es realmente por instancia.

Paso 7: verificar en Play y en Simulate

• Presiona Play: el juego se ejecuta con control del jugador (según la plantilla). Observa el actor rotando.
• Detén Play.
• Ahora usa Simulate: simula el mundo sin “poseer” necesariamente al personaje. Es útil para observar comportamiento de actores en el editor.

Diferencia práctica: Play está orientado a la experiencia de juego (input, cámara, posesión). Simulate es ideal para observar sistemas y actores mientras sigues usando herramientas del editor.

Mini-extensión opcional: exponer también el mesh

Si quieres que el mismo Blueprint sirva para distintos props, puedes permitir cambiar la malla por instancia:

• Crea una variable MeshToUse de tipo Static Mesh y márcala como Instance Editable.
• En Construction Script, asigna MeshToUse al componente Static Mesh.

El Construction Script se ejecuta al construir/actualizar el actor en el editor, lo que permite ver cambios sin entrar en Play.

Estructura recomendada de carpetas para un proyecto ordenado

Una estructura clara reduce tiempo perdido buscando assets y evita duplicados. Ejemplo de organización dentro de Content/:

• Content/Blueprints/
  • Actors/
  • Characters/
  • Components/
  • Interfaces/
  • Systems/ (GameMode, GameInstance, Managers)
• Content/Maps/
• Content/Materials/
  • Master/
  • Instances/
• Content/Meshes/
• Content/Textures/
• Content/UI/
  • Widgets/
  • Fonts/
  • Icons/
• Content/Audio/
• Content/VFX/

Convención de nombres sugerida (consistente y fácil de filtrar):