Bucles y arreglos | Documentación del Centro de creación de Roblox

Arreglos se pueden combinar con bucles, como while y for, para repetir el mismo código para cada valor indexado. Por ejemplo, teletransportar a cada jugador en un arreglo a un nuevo lugar o hacer que un arreglo de partes se incendie.

Para explorar el bucle a través de arreglos, crea un camino de puente que desaparece donde las partes se colocan en un arreglo y luego se hacen desaparecer una por una.

Recorre un arreglo

Para el proyecto, busca o crea un conjunto de tres partes para hacerlas desaparecer. Las partes deben estar ancladas.

Crea tres partes. Nombra las partes en el orden en que deberían desaparecer, Parte1, Parte2, Parte3.
En ServerScriptService, inserta un nuevo script y crea un arreglo para almacenar las partes.
```
local pathArray = {
}
```

En una sola línea cada una, escribe el nombre de las partes en el orden en que deberían desaparecer. Utilizar una nueva línea para cada valor facilita la lectura.


local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3,
}

Usa un bucle for con un arreglo

Usa un bucle for para recorrer el arreglo y controlar qué tan rápido deberían desaparecer las partes en el orden en que están indexadas dentro del arreglo.

Para controlar con qué frecuencia una parte desaparece en segundos, crea una variable llamada VANISH_RATE. Para probar, es mejor mantenerla en un número bajo.
```
local VANISH_RATE = 1.5

local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3
}
```
Constantes son variables que no deberían ser cambiadas por ningún otro código en el script. Probablemente necesiten ajustarse y se colocan al inicio del script en ALL_CAPS para que sean fáciles de identificar.
Crea un bucle for con lo siguiente: Inicio: partIndex = 1, el índice del primer valor en el arreglo. Fin: #pathArray, el tamaño de ese arreglo.
```
for partIndex = 1, #pathArray do

end
```

Para que haya un retraso antes de que una parte desaparezca, en el bucle, añade un task.wait() usando VANISH_RATE.


for partIndex = 1, #pathArray do
   task.wait(VANISH_RATE)
end

Para hacer que una parte desaparezca, crea una nueva variable llamada whichPart y establece su valor igual a pathArray[partIndex]. Luego, para hacer que esa parte desaparezca, establece su propiedad CanCollide en false y Transparency en 1.


for partIndex = 1, #pathArray do
   task.wait(VANISH_RATE)
   local whichPart = pathArray[partIndex]
   whichPart.CanCollide = false
   whichPart.Transparency = 1
end

Verifica que las partes del camino desaparezcan con el tiempo.

Consejos para solucionar problemas

Si el puente no desaparece, verifica los posibles problemas a continuación:

Problema: Las partes desaparecen demasiado rápido o están todas desaparecidas al comienzo.

Dependiendo de qué tan rápido se carga tu personaje en la experiencia, las primeras partes pueden ya estar invisibles. Para solucionar esto, añade una pequeña espera, como task.wait(2), al inicio del script.

Programa el segundo bucle

Ahora mismo, las partes desaparecen para siempre. Para hacer que vuelvan a aparecer, crea un segundo bucle for que recorrerá cada parte y hará que cada pieza sea transitable instantáneamente.

Después del primer bucle, añade un task.wait() para crear un corto retraso antes de que el camino vuelva a aparecer.


for partIndex = 1, #pathArray do
	task.wait(VANISH_RATE)
	local whichPart = pathArray[partIndex]
	whichPart.CanCollide = false
	whichPart.Transparency = 1
end

task.wait(1)

Por tu cuenta, intenta programar un segundo bucle for que haga que el camino sea utilizable nuevamente cambiando la propiedad CanCollide de cada parte a true y Transparency a 0. Cuando termines, comprueba tu trabajo con el código a continuación.


-- Restablece el camino haciendo que todas las partes sean transitables nuevamente
for partIndex = 1, #pathArray do
   local whichPart = pathArray[partIndex]
   whichPart.CanCollide = true
   whichPart.Transparency = 0
end

Las partes no ancladas caerán a través de la base cuando CanCollide sea false. Si las partes no están reapareciendo, y no hay errores de salida, ancla las partes y prueba nuevamente.

Prueba el proyecto para confirmar que una vez que todas las partes desaparezcan, vuelvan a aparecer.

Repite con un bucle while

Las partes desaparecen y reaparecen, pero solo una vez. Para hacer que el código siga repitiéndose, anida todo el código dentro de un bucle while.

Al final del script, crea un nuevo bucle while true do. Luego, mueve ambos bucles for dentro del bucle while.


while true do
   -- Haz que una parte desaparezca del arreglo en orden
	for partIndex = 1, #pathArray do
		task.wait(VANISH_RATE)
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = false
		whichPart.Transparency = 1
	end

	-- Espera un segundo antes de hacer que el camino reaparezca
	task.wait(1)

	-- Restablece el camino haciendo que todas las partes sean transitables nuevamente
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Verifica que una vez que todas las partes desaparezcan, reaparezcan.

Una versión final del proyecto se puede descargar.

Script completado
local VANISH_RATE = 1.0

local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3,
}

while true do
	-- Haz que una parte desaparezca del arreglo en orden
	for partIndex = 1, #pathArray do
		task.wait(VANISH_RATE)
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = false
		whichPart.Transparency = 1
	end

	-- Espera un segundo antes de hacer que el camino reaparezca
	task.wait(1.0)

	-- Restablece el camino haciendo que todas las partes sean transitables nuevamente
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Arreglos e ipairs()

ipairs() se usa con arreglos. La "i" en ipairs() significa "índice". ipairs() se puede utilizar para repetir rápidamente una operación en una gran cantidad de objetos, como un carpeta llena de partes.

Esto se demostrará añadiendo rápidamente partículas a toda una carpeta de partes.

En Workspace, crea una carpeta llamada PartsFolder. Agrega tantas partes como desees.
En ServerScriptService, crea un nuevo script y referencia la carpeta.

Usa GetChildren() para obtener automáticamente un arreglo que liste todos los objetos en la carpeta.


local partsFolder = workspace.PartsFolder

-- Obtiene un arreglo que lista las partes en PartsFolder
local partsArray = partsFolder:GetChildren()

Usa in ipairs(ArrayToUse) con el bucle for para recorrer partsArray y añadir partículas.

Script completado
-- Obtiene un arreglo que lista las partes en PartsFolder
local partsArray = partsFolder:GetChildren()

-- Añade partículas a cada parte en el arreglo
for index, part in ipairs(partsArray) do
	local particles = Instance.new("ParticleEmitter")
	particles.Parent = part
end

Realiza una prueba de juego y observa cómo las partículas flotan desde cada parte de la carpeta.

Resumen

Los bucles se pueden combinar con arreglos para trabajar rápidamente con cualquier número de valores. Si deseas tener un control exacto sobre lo que sucede con algunas partes y en qué orden, un arreglo debe estar codificado de forma rígida con valores específicos.

Para trabajar con muchas partes donde el orden no importa, GetChildren() puede crear un arreglo de los hijos de un objeto. Utilizando ipairs(), la lista se puede recorrer rápidamente sin conocer el tamaño del arreglo.