Programación y arquitectura de código en Unreal Engine

• Vectores, rotaciones, transformaciones.
• Interpolación y LERP.
• Espacios de referencia (local, world, camera).
• Aplicación a movimiento, VFX, físicas, cámaras.

• Fundamentos de algoritmia y lógica aplicada.
• Estructuras de control y flujo condicional.
• Razonamiento lógico para desarrollo de sistemas.
• Análisis de errores y debugging estructurado.

• Tipos de datos básicos y su uso.
• Gestión de eventos: Event BeginPlay, Event Tick, Input Events, Overlap, Hit, OnComponentBeginOverlap, etc.
• Funciones, macros y construcción de lógica reusable.
• Enumeraciones (Enums) y librerías de funciones.
• Blueprint Classes y Herencia de clases.
• Timelines y flujos de ejecución: Sequence, Branch, Delay, Gate, ForEachLoop, Timers, Multigate.
• Comunicación entre actores básicos.
• Debug visual.

• Configuración de Collision Channels, Presets, Object Types, Custom Responses.
• Trazado de rayos (Line Trace, Multi Trace, Sphere Trace, Box Trace) y respuesta a colisiones.
• Interacción avanzada con el entorno: triggers volúmenes, sweep y detección de proximidad.
• ActorComponent y SceneComponent.
• Creación de lógica modular basada en componentes.
• Blueprint Interfaces entre actores complejos.
• Event Dispatcher, Custom Events y timers.
• Debugging

• Estructuras de datos con Structs.
• Gestión de configuraciones con Data Tables (CSV, JSON) y  Row Structs.
• Primary Data Assets para configuración modular.
• Creación de sistemas de configuración de armas, enemigos, niveles, IA, UI, etc.
• Lookup dinámico de datos (por ID, nombre, índice).
• Validación de datos cruzada, hot reload y cambios en tiempo real.

• Configuración y estructura de proyectos C++ en Unreal.
• Creación y derivación de clases principales del motor (AActor, APawn, ACharacter, UActorComponent, AGameModeBase, APlayerController, UGameInstance, etc.).
• Unreal Reflection System: Uso de UPROPERTY, UFUNCTION, UCLASS, etc.
• Métodos del ciclo de vida: BeginPlay, Tick, OnConstruction.
• Compilación, hot reload y flujo de trabajo básico.

• Casting, punteros, referencias y gestión de memoria.
• Enumeraciones en C++.
• Diseño extensible con Interfaces, polimorfismo y Patrón de Estrategia.
• Delegados y Multicast Delegates.
• Comunicación entre Blueprints y C++ (Especificadores).
• Patrón de arquitectura híbrida: clase base en C++, herencia en Blueprint.

• Programación orientada a componentes.
• Separación de lógica de UI, lógica de juego y lógica de red.
• Programación orientada a datos (Data Driven Design).
• Uso de FStructs, Data Tables, Primary Data Assets, Gameplay Tags y Gameplay Abilities.
• Implementación de sistemas modulares escalables.

• Físicas simples: gravedad, Simulate Physics, Physics Materials, Constraints.
• Ragdolls y físicas esqueléticas.
• Interacción física con Blueprints y C++ (AddForce, AddImpulse, LaunchCharacter).
• Triggers, Overlap Events, Hit Events, Sweep, Ignore Actors, Collision Filtering.
• Uso avanzado de trazados (Trace By Channel, Trace For Objects, Trace By Profile).

• Chaos Physics: cuerpos destructibles y tejidos.
• Cloth Simulation: configuración y simulación.
• Physics Fields y fuerzas dinámicas.
• Substepping y sincronización con el framerate.

• Herramientas de depuración visual: Print String, DrawDebug.
• UE_LOG, GEngine->AddOnScreenDebugMessage, DrawDebug, Stat commands.
• Depuración con Visual Studio, Breakpoints, Watch y Call Stack.
• Uso de breakpoints, watch, execution flow.
• Desarrollo de utilidades personalizadas para IA, gameplay y rendimiento.
• Visualización de colisiones, trazados, estado de gameplay.
• Análisis de rendimiento: GPU/CPU Stats, Stat Commands, Unreal Insights y Profiler.
• Creación de tests automatizados: Automation Functional Tests.

• Convenciones de nomenclatura y estandarización.
• Estructura modular del código y separación de lógica por capas..
• Técnicas de refactorización progresiva y documentación.
• Optimización de código, carga y memoria.
• Gestión de memoria y eficiencia.
• Control de versiones y flujos de trabajo profesionales (Git, Perforce).
• Documentación del código, comentarios útiles y generación de documentación automática.
• Refactorización progresiva.

• GameMode, GameState, PlayerController, Pawn.
• Componentes de Input y mapeo con Enhanced Input.
• Movimiento del personaje
• Ciclo de juego: spawn, respawn, inicio y fin de partida.
• Interacción con el entorno.
• Condiciones de victoria y derrota.

• Sistema de Inventario, Recolección y UI interactivas.
• Activadores, uso de ítems, timers y lógica de juego condicional.
• Feedback visual y auditivo.
• Estado del jugador: energía, salud, habilidades temporales.

• Control de personaje
  • Juego 2D: plataformas estilo clásico similar a Super Mario.
• Cámaras avanzadas:
  • Control de cámara juego tipo Resident Evil
  • Control de cámara juego tipo Uncharted.
  • Uso de Camera Shake y Camera Manager.
• Juego de acción RPG:
  • Integración de Gameplay en Animaciones (Anim Notifies)
  • Physical Material
  • Partículas VFX
  • Sonidos
  • Time Dilation
  • Force Feedback

• Diseño modular de mecánicas.
• Integración entre gameplay, UI, audio, VFX e IA.
• Separación de lógica, datos y visualización.
• Ejercicios prácticos con sistemas de combate, progresión, economía.
• Pixel Streaming para streaming remoto.

• Variables replicadas (Replicated, RepNotify).
• Conceptos de autoridad y rol (HasAuthority, Role, RemoteRole).
• Remote Procedure Calls (Server, Client, Multicast).
• Validación y seguridad en red.
• Programación asincrónica (AsyncTask, Latent Actions, Futures, Coroutines).
• Sincronización de gameplay entre jugadores.
• Multiplayer debugging.

• 🕐 Bloque 1 (4h): Fundamentos del Online Subsystem
• 🕑 Bloque 2 (4h): Configuración y puesta en marcha
• 🕒 Bloque 3 (4h): Login y gestión de identidad
• 🕓 Bloque 4 (4h): Creación y gestión de sesiones
• 🕔 Bloque 5 (4h): Publicación inicial y proyecto final

• Arquitectura del GAS.
• Gameplay Tags, Abilities y Effects.
• Setup básico de habilidades.
• Activación simple a habilidades activas y pasivas, coste, cooldown y targeting.
• Integración con personajes y componentes de habilidad.

• Activadores condicionales y respuestas contextuales.
• Aplicación de efectos compuestos.
• Modularización total y escalabilidad del sistema.
• Diseño de sistemas de combate avanzados.
• Integración con UI, feedback y efectos visuales.
• Personalización y escalado de habilidades por Blueprint y C++.

• Extensión del sistema base con lógica específica.
• Integración con sistemas de progresión (XP, niveles, árboles de habilidad).
• Habilidades contextuales, targeting avanzado.
• Extensión con C++ y optimización del GAS.
• Implementación de efectos persistentes o asíncronos.
• Uso de GAS para ejecución en red y sincronización en proyectos multijugador complejos.

• Sistema de guardado con SaveGame.
• Carga dinámica de datos.
• Sincronización entre sesiones y red.

• Diseño de pruebas.
• Instrumentación de sesiones.
• Análisis de usabilidad y comportamiento.
• Creación de Herramientas.
• Testeo con Usuarios

• Python API y automatización de tareas.
• Editor Scripting Utilities y Scriptable Tools.
• Creación de herramientas personalizadas con Editor Utility Widgets.
• Uso de Editor Utility Blueprints para tareas de artista, técnico o programador.
• Batch Processing de assets, escenas y secuencias.
• Integración de comandos personalizados, menús contextualizados y accesos directos.
• Remote Control API.

🕐 Bloque 1 (4h): Fundamentos de porting a consola y requisitos de Switch

🕑 Bloque 2 (4h): Configuración del proyecto para Switch sin DevKit

🕒 Bloque 3 (4h): Optimización visual, lógica y de recursos

🕓 Bloque 4 (4h): Preparación de UI, entrada y soporte técnico específico

🕔 Bloque 5 (4h): Verificación sin DevKit y empaquetado para entrega

🧪 Mini proyecto final del módulo:

Entregar un proyecto “Switch Ready” que funcione con todas las restricciones activas