Bucles y arrays

Los arreglos se pueden combinar con bucles, como mientras y para , para repetir el mismo código para cada valor indexado.Por ejemplo, teletransportar a cada jugador en un array a un nuevo lugar o hacer que un array de partes se desencadenar.

Para explorar la repetición a través de los arrays, crea un camino de puente desaparecedor en el que las partes se colocan en un array y luego se hacen desaparecer una por una.

Repetir a través de un matriz/lista

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

1. Crea tres partes. Nombre las partes en el orden en que deberían desaparecer, Part1, Part2, Part3.

2. En ServerScriptService, inserta un nuevo script y crea un array para almacenar las piezas.

   local pathArray = {
   }

3. En una sola línea cada uno, escriba el nombre de las partes en el orden en que deberían desaparecer. Usar una nueva línea para cada valor facilita la leído.

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

Usa un bucle for con un matriz/lista

Usa un bucle for para recorrer el array y controlar cuán rápido deben desaparecer las partes en el orden en que se indexan dentro del matriz/lista.

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

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

   Las constantes son variables que no deben cambiarse por ningún otro código en el script.Es probable que necesiten ajustarse y se colocan en la parte superior del script en ALL_CAPS para que sean fáciles de detectar.

2. Crea un bucle for con lo siguiendo: Inicio: partIndex = 1 , el índice del primer valor en el matriz/lista. Fin: #pathArray , el tamaño de ese matriz/lista.

   for partIndex = 1, #pathArray  do
   
   end

3. Así que hay 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 que una parte desaparezca, crea una nueva variable llamada whichPart y ponla igual a partsArray[partIndex].Luego, para desaparecer esa parte, establece su propiedad CanCollide en falso 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. Compruebe que partes del camino desaparecen con el tiempo.

Consejos de solución de problemas

Si el puente no desaparece, verifique los problemas posibles a continuación: Problema: Las piezas desaparecen demasiado rápido o se van todas al iniciar.

• Dependiendo de cuán rápido carga tu personaje en la experiencia, las primeras partes pueden ser invisibles.Para abordar esto, agregue una pequeña espera, como task.wait(2) , al comienzo del script.

Codifica el segundo bucle

En este momento, las partes desaparecen para siempre.Para hacerlos reaparecer, crea un segundo bucle que pasará por cada parte y hará que cada pieza sea caminable instantáneamente.

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

   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 propia cuenta , intenta codificar un segundo bucle que haga que el camino sea nuevo de nuevo al cambiar la propiedad CanCollide de cada parte a verdadero y la transparencia a 0.Cuando termines, comprueba tu trabajo contra el código siguiente.

   -- Reinicia el camino haciendo que todas las partes sean caminables de nuevo
   for partIndex = 1, #pathArray do
      local whichPart = pathArray[partIndex]
      whichPart.CanCollide = true
      whichPart.Transparency = 0
   end

   Las piezas sin anclar caerán a través de la placa base cuando CanCollide sea falso.Si las piezas no reaparecen y no hay errores de salida, ancla las piezas y prueba de nuevo.

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

Repetir con un bucle while

Las partes desaparecen y reaparecen, pero solo una vez. Para 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 verdadero. Luego, mueve ambos para bucles al bucle while.

   while true do
      -- Hacer desaparecer una parte de la lista en orden
   	for partIndex = 1, #pathArray  do
   		task.wait(VANISH_RATE)
   		local whichPart = pathArray[partIndex]
   		whichPart.CanCollide = false
   		whichPart.Transparency = 1
   	end
   
   	-- Espere un segundo antes de que reaparezca el camino
   	task.wait(1)
   
   	-- Reinicia el camino haciendo que todas las partes sean caminables de nuevo
   	for partIndex = 1, #pathArray do
   		local whichPart = pathArray[partIndex]
   		whichPart.CanCollide = true
   		whichPart.Transparency = 0
   	end
   end

2. Asegúrate de que una vez que todas las partes desaparezcan, reaparezcan.

Se puede descargar una versión terminada del proyecto.

scriptcompletado
local VANISH_RATE = 1.0

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

while true do
	-- Hacer desaparecer una parte de la lista en orden
	for partIndex = 1, #pathArray  do
		task.wait(VANISH_RATE)
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = false
		whichPart.Transparency = 1
	end

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

	-- Reinicia el camino haciendo que todas las partes sean caminables de nuevo
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Matices y ipairs()

ipairs() se usa con arrays .El "i" en ipairs() representa "índice". ipairs() se puede usar para repetir rápidamente una operación en muchos objetos, como, digamos, una carpeta llena de partes.

Esto se demostrará agregando rápidamente partículas a toda una carpeta de piezas.

1. En el espacio de trabajo, crea una carpeta llamada PartsFolder. Añade tantas piezas como quieras.

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

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

   local partsFolder = workspace.PartsFolder
   
   -- Obtiene un array 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.

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

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

Resumen

Las bucles se pueden combinar con arrays para trabajar con cualquier número de valores rápidamente.Si desea tener un control exacto sobre lo que le sucede a unas pocas partes y en qué orden, debe codificarse un array con valores específicos.

Para trabajar con muchas partes donde el orden no importa, GetChildren() puede crear un array de los hijos de un objeto.Al utilizar ipairs(), la lista se puede iterar rápidamente sin conocer el tamaño del matriz/lista.