Bucles y arreglos

Arreglos pueden ser combinados 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.

Recorrer un arreglo

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

1. Crea tres partes. Nombra las partes en el orden en que deben desaparecer, Parte1, Parte2, Parte3.

2. En ServerScriptService, inserta un nuevo script y crea un arreglo para almacenar las partes.

   local pathArray = {
   }

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

   local pathArray = {
   	workspace.Parte1,
   	workspace.Parte2,
   	workspace.Parte3,
   }

Usa un bucle for con un arreglo

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

1. Para controlar con qué frecuencia desaparece una parte en segundos, crea una variable llamada VANISH_RATE. Para probar, es mejor mantenerlo en un número pequeño.

   local VANISH_RATE = 1.5
   
   local pathArray = {
   	workspace.Parte1,
   	workspace.Parte2,
   	workspace.Parte3
   }

   Constantes son variables que no deben ser cambiadas por ningún otro código en el script. Es probable que necesiten ajustes y se colocan al principio del script en ALL_CAPS para que sean fáciles de identificar.

2. 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

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

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

4. Para hacer que una parte desaparezca, crea una nueva variable llamada whichPart y asígnale el valor pathArray[partIndex]. Luego, para hacer desaparecer esa parte, 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

5. Verifica que las partes del camino desaparezcan con el tiempo.

Consejos de solución de problemas

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

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

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

Codifica el segundo bucle

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

1. Después del primer bucle, agrega un task.wait() para crear un breve retraso antes de que el camino reaparezca.

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

2. Por tu cuenta, intenta codificar 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, verifica tu trabajo con el código a continuación.

   -- Restablecer 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 en Output, ancla las partes y prueba nuevamente.

3. Prueba el proyecto para confirmar que una vez que todas las partes desaparecen, reaparecen.

Repetir 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.

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

   while true do
      -- Hacer 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
   
   	-- Esperar un segundo antes de hacer que el camino reaparezca
   	task.wait(1)
   
   	-- Restablecer 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

2. Verifica que una vez que todas las partes desaparecen, reaparezcan.

Una versión final del proyecto se puede descargar.

local VANISH_RATE = 1.0

local pathArray = {
	workspace.Parte1,
	workspace.Parte2,
	workspace.Parte3,
}

while true do
	-- Hacer 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

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

	-- Restablecer 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 utiliza con arreglos. La "i" en ipairs() significa "índice". ipairs() se puede usar para repetir rápidamente una operación en muchos objetos, como, por ejemplo, una carpeta llena de partes.

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

1. En Workspace, crea una carpeta llamada PartsFolder. Agrega tantas partes como desees.

2. En ServerScriptService, crea un nuevo script y referencia la carpeta.

3. 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()

4. Usa in ipairs(ArrayToUse) con el bucle for para recorrer partsArray y agregar partículas.

   Script completado

   -- Obtiene un arreglo que lista las partes en PartsFolder
   local partsArray = partsFolder:GetChildren()
   
   -- Agrega partículas a cada parte en el arreglo
   for index, part in ipairs(partsArray) do
   	local particles = Instance.new("ParticleEmitter")
   	particles.Parent = part
   end

Prueba el juego y observa cómo las partículas flotan desde cada parte en la carpeta.

Resumen

Los bucles pueden combinarse con arreglos para trabajar con cualquier número de valores rápidamente. Si deseas tener control exacto sobre lo que sucede con algunas partes y en qué orden, un arreglo debe estar codificado 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 iterar rápidamente sin conocer el tamaño del arreglo.