Emisión

El entorno de ejecución expone seis métodos en la cima de la jerarquía de llamadas. Cada uno recibe un ítem transformado (o un ParticleEmitter / Trail nativo) y lo enruta a la implementación correcta por tipo bajo el capó. Los métodos por tipo (:EmitPart, :EmitBeam, etc.) están documentados en Métodos por tipo — la mayor parte del código llama a los despachadores de este capítulo.

Todos los ejemplos asumen que Part_Icles es el módulo requerido y que :Activate ha sido llamado. Ver Ciclo de vida.

Empieza aquí: :AbsoluteEmit es la herramienta principal. Pásale cualquier instancia — un Part transformado, una Folder de emisores transformados y nativos mezclados, un rig de Model completo, incluso workspace — y dispara todo lo que sea emitible dentro del subárbol, usando los atributos propios de cada ítem (EmitCount, EmitDelay, EmitDuration). Una sola llamada, independientemente de cómo esté estructurado el rig, independientemente de qué mezcla de tipos transformados e instancias nativas de ParticleEmitter / Trail vivan en su interior. Si solo aprendes un método de este capítulo, aprende :AbsoluteEmit.

Los demás despachadores (:Emit, :EmitAnimate, :Enable, :EnableEmit, :Disable) existen para los casos en que quieres control preciso sobre un único emisor — cuando “disparar todo” es demasiado amplio, o cuando necesitas condicionar, limitar o interrumpir a mitad de la ejecución. Recurre a ellos cuando hayas superado la simplicidad de :AbsoluteEmit. La herramienta Emit Code del Toolbench genera llamadas a :AbsoluteEmit por defecto precisamente por esa razón.

De un vistazo

Método	Firma	Propósito
:AbsoluteEmit(item)	recursivo, dispara todo	La herramienta principal. Recorre item y sus descendientes; dispara cada emisor transformado y cada ParticleEmitter / Trail nativo del subárbol usando la temporización propia de cada uno. Una llamada, cualquier entrada.
:AbsoluteEnable(item)	estado de encendido recursivo	Recorre item y sus descendientes; pone cada emisor en estado «en marcha» (atributo Enabled = true de la Configuration para los transformados; .Enabled = true para los nativos). Úsalo para efectos ambientales que quieras dejar encendidos indefinidamente.
:AbsoluteDisable(item)	estado de apagado recursivo	Inverso simétrico de :AbsoluteEnable. Detiene cada emisor del subárbol, cancela cualquier bucle activo, oculta cualquier visual del modo Animate.
:Emit(item, link?)	despacho de disparo único	Genera una partícula (o un clon, para tipos de pantalla / imagen / luz). Para un solo emisor, una sola ráfaga.
:EmitAnimate(item, link?)	despacho de Animate de disparo único	Activa la emisión en modo Animate (la fuente reproduce los gráficos en su lugar).
:Enable(item, link?, duration?)	bucle continuo sin más	Inicia un bucle de emisión controlado por Heartbeat a la Rate del ítem. Se detiene cuando transcurre duration o se llama a :Disable.
:EnableEmit(item, link?)	envoltorio de temporización mediante script	Lee EmitCount / EmitDelay / EmitDuration en el ítem y ejecuta la secuencia completa de espera → ráfaga → bucle. El equivalente para un solo emisor de :AbsoluteEmit.
:EnableEmitAt(item, originCF, ctx?)	emisión con anulación de origen	Dispara item en un CFrame mundial específico, ignorando la posición de autoría del objetivo. Lo usa el sistema de Eventos para emisiones encadenadas con orígenes personalizados.
:Disable(item)	detiene todo	Cancela cualquier bucle activo y cualquier ciclo Animate en curso sobre item.

El parámetro opcional link es la misma idea que el campo Link Dir. del capítulo Enlazado — pasa una instancia cuyo CFrame debe rastrear el emisor. Pasa nil (u omítelo) para emisión sin enlace. :AbsoluteEmit no acepta link porque ya opera sobre un subárbol — cada ítem transformado en su interior usa su propia configuración de enlace creada por el autor.

Particle:Emit(item, link?)

Genera una sola partícula. Enruta por tipo: BasePart → :EmitPart, Beam → :EmitBeam, etc. (lista completa en Métodos por tipo).

Part_Icles:Emit(workspace.ExplosionFX)

Una llamada produce una partícula. :Emit no lee EmitCount — ese atributo pertenece a :EnableEmit, que itera sobre :Emit EmitCount veces. Para disparar muchas partículas a la vez, llama a :Emit en un bucle tú mismo o usa :EnableEmit y deja que lea los atributos. Para emisión continua a la Rate del ítem, usa :Enable.

Si item es nil o no tiene padre, :Emit retorna silenciosamente. Si item es un tipo no reconocido, :Emit no hace nada.

Para ítems en modo Animate, :Emit NO redirige automáticamente a Animate — llama a :EmitAnimate explícitamente.

Trail no es despachado por :Emit (ni por :Enable / :EnableEmit). Los Trails usan una ruta de almacenamiento distinta sin hijo Configuration, por lo que la búsqueda por tipo devuelve nil y no hay método de emisión de Trail por tipo al que llamar. Usa :AbsoluteEmit para un Trail transformado — su rama de Trail nativo parsea EmitDuration y alterna Enabled. O simplemente alterna trail.Enabled tú mismo.

Particle:EmitAnimate(item, link?)

Despachador del modo Animate. Para tipos 3D (Part / Beam / Attachment / Model), la instancia fuente reproduce sus gráficos en su lugar; sin clones. Para tipos de espacio de pantalla (Blur / Bloom / ColorCorrection / Atmosphere / ImageLabel), la llamada produce un clon singleton — como máximo un clon Animate vivo por fuente a la vez. Un segundo :EmitAnimate mientras el primero está a mitad de ciclo se descarta silenciosamente.

Part_Icles:EmitAnimate(workspace.PulsingOrb)

Si el ítem tiene AnimateLoop = true, el Heartbeat vuelve a activar el ciclo cuando termina — llama a :Disable para detenerlo. Con AnimateLoop = false, el ciclo se reproduce una vez y la fuente vuelve a su estado inicial.

Atmosphere está anclado forzosamente al modo Animate en el momento de la transformación. :EmitAnimate(myAtmosphere) es la llamada correcta para él.

Particle:Enable(item, link?, duration?)

Bucle de emisión continua. Genera un hilo con task.spawn que llama a :Emit(item, link) repetidamente a la Rate del ítem (partículas por segundo) hasta que ocurra uno de los siguientes eventos:

• Transcurren duration segundos (por defecto math.huge — se ejecuta indefinidamente)
• El padre del ítem se convierte en nil (fue eliminado)
• Se llama a :Disable(item)
• El atributo Enabled del hijo Configuration cambia a false

Part_Icles:Enable(workspace.WaterFountain)             -- runs until you stop it
Part_Icles:Enable(workspace.SmokeStack, nil, 30)       -- runs for 30s
Part_Icles:Enable(workspace.SwordSpark, sword.Tip, 2)  -- linked, 2s

El bucle usa un acumulador — los valores de Rate por debajo del fotograma aún se generan correctamente. Una Rate de 200 en un tick a 60Hz produce ~3,33 partículas por fotograma, alternando 3 y 4 entre fotogramas para que la media a largo plazo coincida.

Cortocircuito del modo Animate: si el ítem tiene EmissionMode = "Animate", :Enable establece AnimateLoop = true y llama a :EmitAnimate en su lugar. El Heartbeat se encarga de la reactivación — no hay hilo de bucle separado.

Particle:EnableEmit(item, link?)

El despachador completo de temporización mediante script. Lee tres atributos en item:

• EmitCount (valor de reserva del lado del script: 1 si falta el atributo) — cuántas ráfagas instantáneas al inicio.
• EmitDelay (por defecto 0) — segundos de espera antes de la primera ráfaga.
• EmitDuration (por defecto 0) — segundos de bucle continuo después de las ráfagas iniciales. 0 = sin bucle.

Incremento automático: si tanto EmitCount como EmitDuration se leen como 0 (el valor por defecto para un Part / Attachment / Model / PointLight recién transformado cuya temporización el usuario no ha configurado), :EnableEmit trata la llamada como “disparar una vez” y ejecuta una sola ráfaga. Sin esto, un ítem con cero por defecto no produciría ninguna emisión.

Luego ejecuta:

1. Esperar EmitDelay.
2. Activar EmitCount ráfagas instantáneas mediante :Emit.
3. Si EmitDuration > 0, iniciar :Enable durante esos segundos.

spell:SetAttribute("EmitCount",    3)
spell:SetAttribute("EmitDelay",    0.2)
spell:SetAttribute("EmitDuration", 1.5)
Part_Icles:EnableEmit(spell)

→ espera 0,2s, dispara 3 ráfagas, luego ejecuta en bucle continuamente durante 1,5s.

Esta es la llamada correcta para efectos cuya temporización fue creada en el propio ítem — el script simplemente dice “ejecútalo” y los atributos se encargan del resto.

Comportamiento del modo Animate: si EmissionMode = "Animate", la llamada respeta EmitDelay y usa EmitDuration para limitar cuánto tiempo permanece AnimateLoop en true. EmitCount no se usa (el modo Animate no dispara ráfagas).

Particle:Disable(item)

Detiene todo lo que se ejecuta en item:

• Cualquier bucle :Enable continuo se cancela.
• Cualquier ciclo Animate en curso se cancela y el CFrame de la fuente se restaura.
• El atributo Enabled del hijo Configuration cambia a false para que el listener automático no lo reinicie.

Part_Icles:EnableEmit(stream)
task.wait(0.5)
Part_Icles:Disable(stream)  -- cut short

Las partículas clon en vuelo (ya emitidas) NO se eliminan — terminan sus tiempos de vida de forma natural. Solo se detiene la generación de nuevas partículas.

Particle:AbsoluteEmit(item)

El despachador de disparar todo. Pásale cualquier instancia y activa todos los emisores que contiene el subárbol, independientemente de cómo esté organizado ese subárbol — carpetas, modelos, attachments que contienen hijos transformados, padres transformados que contienen hijos nativos ParticleEmitter y Trail, todo.

Por qué esta es la herramienta principal. Los rigs de VFX reales no son emisores únicos. Una explosión es un destello más una onda de choque más escombros más humo más una luz más un tinte de pantalla más un desenfoque — seis o siete emisores, cada uno con su propia temporización creada por el autor. Un lanzamiento de hechizo es un resplandor más chispas orbitantes más un haz más un destello de UI. Crear esos rigs como una Folder (o Model) de hijos transformados, y luego activar todo el rig con una sola llamada a :AbsoluteEmit, es el patrón canónico. No tienes que enumerar los hijos en tu script de activación; no tienes que recordar cuáles de ellos están transformados y cuáles son nativos; no tienes que llamar a un despachador diferente por tipo. Una sola llamada.

También significa que el script y la autoría permanecen desacoplados. Si añades un nuevo emisor al rig en Studio (insertas otro Beam, otro PointLight), la llamada a :AbsoluteEmit existente en tu script de hechizo lo detecta la próxima vez que lo activas — sin necesidad de editar el script. La estructura y temporización del rig viven en Studio; el activador es una sola línea.

Lógica de despacho. Cuando llamas a :AbsoluteEmit(item), el entorno de ejecución comprueba item contra cuatro casos, en orden:

1. item tiene Transformed = true (es un emisor transformado por el plugin — Part / Beam / Attachment / Model / PointLight / ImageLabel / Blur / Bloom / ColorCorrection / Atmosphere) → llama a :EnableEmit(item, nil). Se ejecuta el flujo completo de temporización mediante script: espera de EmitDelay → ráfagas instantáneas de EmitCount → bucle continuo acotado por EmitDuration. Cada ítem transformado usa sus propios atributos creados por el autor. Para aquí; no recurses en el subárbol del ítem transformado.
2. item es un ParticleEmitter nativo (el PE estándar de Roblox, nunca transformado) → dispara su :Emit(EmitCount) nativo para una ráfaga instantánea, luego si EmitDuration > 0 alterna .Enabled = true durante esos segundos y vuelve a false. EmitCount toma por defecto 1 y EmitDuration 0 si los atributos están ausentes. Para aquí.
3. item es un Trail (nativo o transformado — el diseño de directAccess de Trail hace que el entorno de ejecución trate ambos de la misma manera; ninguno lleva el atributo Transformed) → parsea EmitDuration (una cadena, número único o rango "min,max") y pulsa Enabled = true → false durante la duración parseada. Si EmitDuration se parsea como 0 o falla, el pulso se omite. Para aquí.
4. item es cualquier otra cosa (un BasePart, un Attachment, un Model, una Folder, el workspace, un Frame de UI, …) → recurse en item:GetChildren() y ejecuta el mismo despacho en cada hijo. Las instancias nativas de ParticleEmitter / Trail dentro de contenedores BasePart / Attachment / Model también se disparan mediante un barrido separado que recorre :GetDescendants(), así que no tienes que preocuparte por la profundidad.

La recursión se detiene en cada ítem transformado o emisor nativo que encuentra — no se desciende en ellos, porque su propio :EnableEmit (o disparo nativo) gestiona la clonación. Si anidas un Part transformado dentro de una Folder dentro de otra Folder, :AbsoluteEmit aún lo encontrará. Si anidas un Part transformado dentro del RenderTemplate de otro Part transformado, ese es el patrón de emisor anidado — el Part exterior gestiona su emisión por sí solo.

Ejemplos.

Una carpeta simple de emisores mezclados:

local rig = workspace.ExplosionVFX
-- ExplosionVFX/
--   CoreFlash       (transformed Part)
--   Shockwave       (transformed Beam)
--   Smoke           (transformed Part)
--   Light           (transformed PointLight)
--   ScreenColor     (transformed ColorCorrection)
--   ScreenBlur      (transformed Blur)
--   AmbientSparks   (native ParticleEmitter — set its EmitCount attribute manually)
--   FlashTrail      (native Trail — set its EmitDuration attribute as "0.3")

Part_Icles:AbsoluteEmit(rig)

→ los ocho emisores se disparan juntos, cada uno con su propia temporización creada por el autor.

Una plantilla de VFX clonada (el patrón típico de “generar un efecto en una posición”):

local function castSpell(originPosition)
    local effect = ReplicatedStorage.SpellVFX:Clone()
    effect:PivotTo(CFrame.new(originPosition))
    effect.Parent = workspace.Effects
    Part_Icles:AbsoluteEmit(effect)
    task.delay(5, function() effect:Destroy() end)
end

Un Model completo (por ejemplo, una bola de fuego donde toda la bola de fuego es el rig):

local fireball = ReplicatedStorage.FireballVFX:Clone()
fireball:PivotTo(CFrame.new(spawnPos))
fireball.Parent = workspace.Effects
Part_Icles:AbsoluteEmit(fireball)

Los efectos adjuntos completos de un personaje (cada emisor que lleva el jugador — auras, armas, UI):

Part_Icles:AbsoluteEmit(player.Character)

→ todos los emisores dentro de la jerarquía del personaje se disparan una vez. Si has creado un aura en el torso, chispas en un Attachment de la punta de una espada, y un destello de UI en el HUD del jugador, los tres se activan juntos.

:AbsoluteEmit no emite continuamente — activa la temporización de emisión creada por el autor una sola vez. Para efectos ambientales continuos (fuentes, antorchas), usa :AbsoluteEnable (descrito a continuación) en su lugar.

La herramienta Emit Code del Toolbench genera llamadas a :AbsoluteEmit por defecto para cualquier selección de varios componentes, por la misma razón: es el activador correcto más simple para cualquier forma de rig.

Particle:AbsoluteEnable(item)

El despachador recursivo de estado de encendido. Recorre item y sus descendientes de la misma forma que lo hace :AbsoluteEmit y pone cada emisor que encuentra en un estado «en marcha» — el atributo Enabled de la Configuration de los emisores transformados pasa a true, las instancias nativas ParticleEmitter / Trail reciben .Enabled = true. La temporización creada por el autor sigue aplicándose (un ítem con un EmitDelay distinto de cero espera antes de su primera ráfaga; un ítem con un EmitDuration finito se ejecuta durante ese tiempo y luego se detiene de forma natural), pero el despachador en sí no impone una duración — los emisores siguen encendidos hasta que llamas a :AbsoluteDisable, hasta que el script borra su atributo Enabled, o hasta que su padre desaparece.

-- Player enters a fog zone — turn on every emitter in the AmbientFog folder
Part_Icles:AbsoluteEnable(workspace.Effects.AmbientFog)

Esta es la llamada correcta para efectos ambientales o ligados a una zona: una antorcha que debe brillar mientras esté en la escena, un parche de niebla que debe pulsar mientras el jugador esté dentro, un arma cargándose cuyas partículas deben fluir desde el momento en que se mantiene el gatillo hasta que se suelta. No tienes que enumerar los hijos, no tienes que recordar cuáles están transformados, no tienes que cablear scripts de activación por ítem — una llamada, un estado.

Particle:AbsoluteDisable(item)

El inverso simétrico. Recorre item y sus descendientes y detiene cada emisor del subárbol: cancela cualquier bucle continuo activo, detiene cualquier ciclo del modo Animate en curso, establece Enabled = false en las Configurations transformadas y .Enabled = false en los PE / Trail nativos.

-- Player leaves the fog zone — turn off the whole folder
Part_Icles:AbsoluteDisable(workspace.Effects.AmbientFog)

Las partículas clon en vuelo que ya están en el mundo terminan sus tiempos de vida de forma natural; solo se detiene la nueva generación. Para los ítems en modo Animate, la fuente vuelve a su estado inicial y deja de hacer bucle.

:AbsoluteDisable es la llamada correcta cuando previamente activaste un rig con :AbsoluteEnable y ahora necesitas apagarlo. Para los rigs de un solo disparo activados con :AbsoluteEmit, normalmente no necesitas llamar a disable — las ráfagas se completan por sí solas. Disable es para efectos con estado persistente.

Elegir el método correcto

Un árbol de decisiones:

• Una ráfaga instantánea → :Emit
• Emisión continua sin fin → :Enable(item) (sin duración), o :AbsoluteEnable(folder) para rigs con muchos emisores
• Emisión continua durante N segundos → :Enable(item, link, N)
• Efecto con temporización integrada en atributos (count + delay + duration) → :EnableEmit
• Ítem en modo Animate → :EmitAnimate (o :Enable, que hace cortocircuito hacia Animate cuando EmissionMode = "Animate"; :Emit no redirige automáticamente — usa :EmitAnimate directamente)
• Folder/model que contiene muchos emisores, disparar una vez → :AbsoluteEmit
• Folder/model que contiene muchos emisores, ejecutar de forma continua → :AbsoluteEnable (y :AbsoluteDisable para detenerlos)
• Cancelar cualquiera de los anteriores → :Disable (un solo emisor) o :AbsoluteDisable (subárbol completo)

La mayor parte del código de juego usa :EnableEmit para efectos activados, :Emit para impactos y destellos, :AbsoluteEmit para rigs ensamblados de un solo disparo, y :AbsoluteEnable / :AbsoluteDisable para carpetas ambientales / ligadas a estado. :Enable y :EmitAnimate son situacionales.

Qué sigue

Los despachadores enrutan hacia implementaciones por tipo. Si necesitas omitir el despacho (ligeramente más rápido, ligeramente más explícito), el capítulo Métodos por tipo cubre directamente los 10 métodos de modo emit + 9 métodos de modo animate. De lo contrario, Anclaje de texturas es el siguiente — :Preload y :Deload para mantener los bytes de los assets en memoria.