Lógica visual en Blueprints: nodos, ejecución y datos

El modelo mental: dos “cables” distintos

En Blueprints conviven dos flujos simultáneos: ejecución (cuándo ocurre algo) y datos (qué valores se usan). Entender esta separación te permite leer cualquier gráfico con rapidez y evitar errores típicos como “tengo el valor correcto pero no se ejecuta” o “se ejecuta pero el valor no es el esperado”.

Pines de ejecución (Exec)

• Se representan como pines con cable blanco.
• Definen el orden: qué nodo se dispara primero y cuál después.
• Un nodo con Exec normalmente tiene un pin de entrada (por ejemplo Exec) y uno o varios de salida (por ejemplo Then).

Pines de datos

• Transportan valores (números, vectores, referencias, etc.).
• Su color indica el tipo (más abajo verás una guía rápida).
• Los datos pueden “viajar” aunque no haya Exec, pero solo se evaluarán cuando un nodo que los necesite sea ejecutado (o cuando se trate de una función pura que se evalúa al pedir su salida).

Cómo se lee un Blueprint: izquierda a derecha

La lectura típica es: evento o llamada a la izquierda, luego decisiones y operaciones en el centro, y finalmente acciones/efectos a la derecha (por ejemplo, cambiar una variable, mover un actor, reproducir un sonido). Mantener esta convención mejora la legibilidad y reduce el tiempo de depuración.

Regla práctica

• Si un nodo “hace algo” (cambia estado, spawnea, mueve, imprime), casi siempre es impuro y necesita Exec.
• Si un nodo “calcula algo” (suma, normaliza, convierte tipos), a menudo es puro y no necesita Exec.

Lectura de tipos comunes (y qué significan)

Los tipos determinan qué puedes conectar con qué. Si intentas conectar tipos incompatibles, Blueprints te lo marcará o insertará una conversión automática (cuando exista). Aprende a reconocerlos por su nombre y uso.

Consejo: usa Name para etiquetas/IDs y String para UI o concatenación de texto. Para interactuar con algo en el mundo, normalmente necesitarás una Object Reference.

Nodos comunes: crear, conectar y entender su intención

Crear nodos rápidamente

• Clic derecho en el gráfico y escribe el nombre del nodo (por ejemplo Branch, Print String, Set + nombre de variable).
• Arrastra desde un pin y suelta en vacío: el menú se filtra por tipos compatibles (muy útil para evitar errores).

Branch (if) y condiciones

Branch es el nodo base para decisiones. Tiene Exec de entrada, un pin Condition (bool) y dos salidas Exec: True y False.

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

[Exec] --> Branch(Condition=IsSprinting) --True--> (Acción A) --False--> (Acción B)

Set/Get de variables

• Get lee el valor (normalmente puro).
• Set escribe el valor (impuro, con Exec).

Patrón típico: calcular un valor con nodos puros y luego asignarlo con un Set al final del flujo.

Operaciones matemáticas encadenadas

Los nodos de suma, resta, multiplicación y división existen para int, float y también para vector (por ejemplo sumar un offset a una posición). Encadenar operaciones es común, pero conviene agruparlas visualmente y comentar la intención.

Funciones puras vs impuras (y por qué importa)

Función pura

• No tiene pines Exec.
• No debería modificar estado; solo devuelve resultados.
• Se evalúa cuando algún nodo necesita su salida.

Ejemplos típicos: GetActorLocation (en muchos contextos), Vector Length, conversiones de tipo.

Función impura

• Tiene pines Exec.
• Puede modificar estado o depender del orden de ejecución.

Ejemplos: SetActorLocation, SpawnActor, Print String, Set de variables.

Regla práctica: si necesitas garantizar “primero calcula, luego aplica”, termina en un nodo impuro (por ejemplo Set o SetActorLocation) y alimenta sus pines de datos con cálculos puros.

Legibilidad: comentarios, alineación y orden

Comentarios

• Selecciona nodos y presiona C para crear un comentario.
• Nombra el comentario por intención: “Calcular velocidad final”, “Validar referencia”, “Construir Transform de spawn”.

Alineación y limpieza

• Evita cables cruzados: reubica nodos para que el flujo vaya recto.
• Usa “reroute nodes” (doble clic en un cable) para guiar cables largos y mantener orden.
• Agrupa por etapas: entrada (evento), validación, cálculo, acción.

Guía práctica 1: conversiones de valores (cast/convert)

Objetivo: tomar un int de munición, convertirlo a string y mostrarlo. Además, convertir un float a int para un contador.

Paso a paso: int a string para UI/depuración

• Crea/usa una variable Ammo (int).
• Coloca un Get Ammo.
• Desde el pin de Ammo, arrastra y busca ToString (int) o Conv_IntToString (según versión).
• Conecta el resultado a Print String (impuro) para verificar.

Event (alguno) --> Print String( InString = ToString(Ammo) )

Paso a paso: float a int (redondeo)

• Obtén un float (por ejemplo Speed).
• Elige el tipo de conversión según intención: Floor (hacia abajo), Ceil (hacia arriba), Round (al más cercano) o Truncate (corta decimales).
• Conecta el resultado a un Set de una variable SpeedInt (int) o a un ToString para imprimir.

Ejercicio: prueba las cuatro opciones con el valor 9.9 y observa el resultado. Documenta en un comentario cuál usarías para “balas mostradas” vs “tiempo restante”.

Guía práctica 2: construir Vectors y Rotators (Make) y desglosarlos (Break)

Muchas APIs trabajan con estructuras como Vector, Rotator y Transform. Blueprints ofrece nodos Make (construir) y Break (separar) para editar componentes.

Construir un Vector (Make Vector)

• Crea tres float: X, Y, Z (o usa valores literales).
• Agrega Make Vector y conecta X/Y/Z.
• Usa el vector como offset o posición.

NewLocation = GetActorLocation() + MakeVector(X=100, Y=0, Z=0)

Desglosar un Vector (Break Vector)

• Conecta un Vector a Break Vector.
• Obtendrás X, Y, Z como floats para comparar o modificar.

Ejercicio: toma GetActorLocation, haz Break Vector y crea un Branch que sea verdadero si Z > 200. Imprime “Alto” o “Bajo”.

Construir una Rotación (Make Rotator)

• Agrega Make Rotator y define Yaw para girar en el eje vertical.
• Úsalo para orientar un actor o un componente.

Nota: en muchos casos, para rotaciones en gameplay conviene trabajar con Yaw y dejar Pitch/Roll en 0, salvo que estés apuntando o inclinando.

Guía práctica 3: encadenar matemáticas con intención (y sin perderte)

Objetivo: calcular un daño final con modificadores y límites: FinalDamage = Clamp( BaseDamage * Multiplier + Bonus, 0, MaxDamage ).

Paso a paso

• Crea variables BaseDamage (float), Multiplier (float), Bonus (float), MaxDamage (float).
• Coloca nodos: * (float*float), luego +, luego Clamp (float).
• Conecta el resultado a un Set FinalDamage o úsalo directamente donde se aplique el daño.
• Encierra los nodos de cálculo en un comentario: “Cálculo de daño final”.

FinalDamage = Clamp( (BaseDamage * Multiplier) + Bonus, 0, MaxDamage )

Ejercicio: añade un Branch que aplique Bonus solo si un bool IsCritical es verdadero. Pista: usa un Select (Float) para elegir Bonus o 0 sin romper el flujo.

Break/Make de Transform: mover y spawnear con precisión

Transform agrupa Location (Vector), Rotation (Rotator) y Scale (Vector). Es común para spawns y para setear transformaciones completas.

Modificar solo una parte del Transform

• Obtén un Transform (por ejemplo GetActorTransform).
• Usa Break Transform para separar Location/Rotation/Scale.
• Modifica solo lo necesario (por ejemplo sumar un offset a Location).
• Reconstruye con Make Transform y aplícalo con un nodo impuro (por ejemplo SetActorTransform).

Referencias a actores en escena: obtener y establecer datos

Para leer o cambiar datos de un actor existente necesitas una referencia a ese actor. Esa referencia puede venir de una variable expuesta, de una búsqueda, de un evento de colisión, o de un “Get” del mundo.

Patrón seguro: validar antes de usar

Si una referencia puede ser nula (None), valida con Is Valid antes de acceder a sus variables o llamar funciones.

Exec --> IsValid(TargetActor) --Valid--> (Usar TargetActor) --Not Valid--> (Manejar error)

Guía práctica: usar una referencia asignada desde el editor

• Crea una variable TargetActor de tipo Actor Object Reference.
• Márcala como Instance Editable (editable por instancia) para asignarla en el nivel.
• En el nivel, selecciona la instancia del blueprint y asigna el actor objetivo en el panel de detalles.
• En el gráfico, usa Is Valid y luego llama GetActorLocation del TargetActor para leer su posición.
• Opcional: usa SetActorLocation para mover el actor (esto es impuro y requiere Exec).

Guía práctica: obtener una referencia y leer/escribir una variable

Si el actor objetivo es de una clase específica (por ejemplo un blueprint BP_Door con variable IsOpen), necesitarás una referencia tipada a esa clase para acceder a sus miembros.

• Consigue la referencia (por ejemplo desde una variable, un overlap, o una selección en el editor).
• Si la referencia es genérica (Actor), usa un Cast To BP_Door para acceder a IsOpen.
• Tras el cast exitoso, usa Get IsOpen o Set IsOpen.

Ejercicio: crea un bool ShouldOpen en tu blueprint actual. Si TargetActor es una puerta, haz cast y setea IsOpen = ShouldOpen. Añade un Print String en el fallo del cast para detectar referencias incorrectas.

Checklist de depuración rápida (sin herramientas avanzadas)

• ¿El flujo Exec llega al nodo final? Si no, revisa eventos, branches y conexiones blancas.
• ¿Los datos son del tipo correcto? Si hay conversiones implícitas, considera hacerlas explícitas para claridad.
• ¿Estás usando una función pura esperando que “haga algo”? Si debe cambiar el mundo, necesitas un nodo impuro.
• ¿La referencia a un actor es válida? Usa Is Valid y maneja el caso None.
• ¿Tu gráfico se lee de izquierda a derecha? Reordena y comenta por intención.