Tus propias piezas de BreynFlow (tutorial)

Capítulo 1Tu IA puede ayudarte

Antes de empezar, algo importante: no tienes que hacer esto solo. BreynGINE puede preparar un archivo que enseña a tu asistente de IA (ChatGPT, Claude, Gemini, Grok...) cómo funciona BreynFlow: todas las piezas con sus campos, los objetos listos para usar y cómo se hacen las piezas propias. Con él, la IA te puede escribir una pieza entera, explicarte cada línea o arreglar la que no te funciona.

La IA te dará el código de la pieza listo para pegar, y también puede darte reglas como texto. Esas reglas se pegan de una vez: en la pantalla BreynFlow, pulsa Pegar reglas..., pega el texto y pulsa Añadir las reglas. Antes de añadirlas verás cómo se leen, frase a frase, y cualquier problema que tengan.

Si prefieres aprender a hacerlo tú (o entender lo que te ha escrito la IA), sigue: en este tutorial creas una pieza paso a paso.

Capítulo 2Lo que vas a hacer

BreynFlow trae muchísimas piezas: eventos (CUANDO), condiciones (SI) y acciones (HAZ). Pero a veces te falta justo una. Para eso están las piezas propias: un archivo corto de GDScript que BreynFlow enseña en el buscador y usa como cualquier otra pieza.

Vas a crear Latir, una acción que hace que un objeto crezca y vuelva a su tamaño unas cuantas veces, como un corazón. En la regla se leerá así: «hacer latir este objeto 3 veces en 1 s», y podrás tocar cada valor para cambiarlo, como en las piezas de BreynGINE.

Después verás cómo cambiar su código, qué son los espacios de nombres y cómo reunir tus piezas en un paquete para compartirlas o venderlas.

Capítulo 3Prepara un objeto

Puedes usar cualquier proyecto de juego. Si quieres empezar de cero, crea uno nuevo con la plantilla 2D (cámara).

Ya tienes una regla que dice «Cuando empieza la escena». Falta lo que hace: ahí irá tu pieza.

Capítulo 4Crea la pieza

Pasan tres cosas a la vez: se crea el archivo res://piezas/latir.gd con una plantilla, la pieza se añade a tu regla y su código se abre en la pantalla Script.

Capítulo 5Lo que trae la plantilla

La plantilla ya funciona: es una pieza de ejemplo con comentarios (las líneas que empiezan por #) que explican cada parte. Estas son las importantes:

• @tool: permite que el editor use la pieza mientras trabajas (para enseñarla en el buscador y en las reglas). Siempre va la primera.
• class_name Latir: el nombre de la pieza en el código.
• extends FlowAction: dice que es una acción. Una condición sería FlowCondition y un evento, FlowEvent.
• Las líneas @export var: los campos que se rellenan en la regla. Un campo FlowTarget es «qué objeto» (vacío quiere decir este objeto).
• _get_piece_info(): cómo se ve la pieza. Su nombre, su frase (cada campo va entre llaves, como {objetivo}), su categoría, su descripción y un ejemplo.
• _execute(context): lo que hace la pieza. Devuelve true cuando ha terminado.

Capítulo 6Escribe Latir

Ahora cambia la plantilla por la pieza de verdad. Selecciona todo el código (Ctrl+A) y cámbialo por este (con Copiar el código lo tienes en el portapapeles; pégalo con Ctrl+V):

@tool
class_name Latir
extends FlowAction

# Los campos de la pieza: qué objeto late (vacío: este objeto), cuántas veces,
# en cuántos segundos y cuánto crece (1,3 es un 30 % más grande).
@export var objetivo: FlowTarget
@export var veces := 3
@export var segundos := 1.0
@export var tamaño := 1.3

func _get_piece_info() -> Dictionary:
	return {
		"name": "Latir",
		"sentence": "hacer latir {objetivo} {veces} veces en {segundos} s",
		"category": "Mis piezas",
		"description": "Hace que un objeto crezca y vuelva a su tamaño unas cuantas veces, como un corazón.",
		"example": "Empieza la escena: hacer latir este objeto 3 veces en 1 s.",
	}

# Empieza: guarda el tamaño de cada objeto y pone el reloj a cero.
func _execute(context: FlowContext) -> bool:
	var inicio := {}
	for objeto in context.get_targets(objetivo):
		if "scale" in objeto:
			inicio[objeto] = objeto.scale
	context.set_state(self, &"inicio", inicio)
	context.set_state(self, &"tiempo", 0.0)
	return false # Todavía no ha terminado: la regla espera.

# Cada fotograma, hasta que devuelve true: crece y encoge.
func _process_action(context: FlowContext, delta: float) -> bool:
	var tiempo: float = context.get_state(self, &"tiempo", 0.0) + delta
	context.set_state(self, &"tiempo", tiempo)
	var terminado := tiempo >= segundos
	var crecer := 0.0 if terminado else absf(sin(tiempo / segundos * veces * PI))
	var inicio: Dictionary = context.get_state(self, &"inicio", {})
	for objeto in inicio:
		if is_instance_valid(objeto):
			objeto.scale = inicio[objeto] * (1.0 + (tamaño - 1.0) * crecer)
	return terminado

Guarda con Ctrl+S.

Cómo funciona

• _execute() se llama una vez, cuando la regla llega a la pieza. Apunta el tamaño de cada objeto y devuelve false: «todavía no he terminado».
• Mientras no termine, BreynFlow llama a _process_action() en cada fotograma. La pieza calcula cuánto crecer con una onda (la función sin) y devuelve true cuando han pasado los segundos. Entonces la regla sigue con la acción siguiente.
• get_state() y set_state() guardan los valores de cada vez que se usa la pieza. Es importante: si diez enemigos tienen la misma regla, comparten la pieza, así que lo que cambia mientras el juego corre no se guarda en sus variables.

Capítulo 7Úsala en la regla

Vuelve a la pantalla BreynFlow. Tu regla ya dice:

«Cuando empieza la escena: hacer latir este objeto 3 veces en 1 s». Toca cualquier valor resaltado para cambiarlo: pon 5 veces, o 2 segundos.

Pulsa ▶ (arriba) para probar el juego: el corazón late al empezar.

Tu pieza ya está en el buscador para siempre, en la categoría Mis piezas. La puedes usar en cualquier regla de este proyecto, con cualquier evento: al tocar al jugador, al recibir un mensaje, cada 2 segundos...

Cambiar el código después

En la regla, el menú de la pieza (los tres puntos ⋮) tiene Editar el código de la pieza: abre su archivo en la pantalla Script. Cambia lo que quieras y guarda: todas las reglas que la usan cambian a la vez.

Capítulo 8Espacios de nombres

Fíjate en el buscador de piezas: bajo el nombre de cada pieza, en pequeño, sale de dónde viene. Es su espacio de nombres:

• BreynGINE: las piezas que trae BreynGINE.
• Mis piezas: las de tu proyecto, como Latir.
• autor.paquete: las de un paquete de piezas (el siguiente capítulo).

Con el desplegable que hay junto a la búsqueda puedes ver solo las de uno de ellos.

Gracias a los espacios de nombres, dos piezas pueden llamarse igual sin liarse: el «Latir» de tu proyecto y el «Latir» de un paquete que te descargues son dos piezas distintas, y en el buscador sabes cuál es cuál.

Capítulo 9Haz un paquete

Un paquete reúne varias piezas para compartirlas con otras personas o venderlas en la tienda. Es una carpeta res://addons/autor/paquete/ con las piezas dentro y un archivo pack.cfg que dice su nombre, su autor, su versión y su descripción.

Para empezar uno:

Las siguientes piezas del paquete las creas igual, eligiendo el paquete en Dónde se guarda.

Compártelo

Para compartir un paquete, comparte su carpeta (por ejemplo, comprimida en un ZIP). Quien la copie en la carpeta addons de su proyecto tendrá tus piezas en su buscador, con tu espacio de nombres. Y pronto podrás publicarlo en la tienda de BreynGINE.

Abre pack.cfg (en el panel Proyecto) para escribir su descripción y subir su versión cuando lo mejores.

Capítulo 10Y ahora, tú

Ya sabes hacer piezas propias. Algunas ideas para seguir:

• Una condición (FlowCondition): «la vida es par», «es de noche». Su función es _check(context) y devuelve true o false.
• Un evento (FlowEvent): «cada 3 saltos», «se agita el ratón». Dispara la regla con flow.trigger_rule(rule_index).
• Pídele ideas a tu IA con la Guía para tu IA: con tu proyecto incluido, sabe exactamente qué piezas tienes y cuáles te faltan.