Círculos y Arrays

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

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

Recorrido a través de una matriz

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

1. Crea tres partes. Ponle nombre a las partes en el orden en que deberían desaparecer, Parte1, Parte2, Parte3.

2. En ServerScriptService, inserte un nuevo script y cree un array para almacenar las partes.

   local pathArray = {
   }

3. En una sola línea cada una, escriba el nombre de las partes en el orden en que deberían desaparecer. Usar una nueva línea para cada valor hace que sea más fácil de leído.

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

Usando un para bucle con una matriz

Usa un bucle para pasar por el conjunto y controlar qué tan rápido deberían desaparecer las partes en el orden en que están indexadas dentro del matriz/lista.

1. Para controlar la frecuencia con la que una parte desaparece 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.Part1,
   	workspace.Part2,
   	workspace.Part3
   }

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

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

   for partIndex = 1, #pathArray  do
   
   end

3. Entonces hay un retraso antes de que una parte desaparezca, en el bucle, agregue 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 que esa parte desaparezca, pon 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. Comprueba que partes del camino desaparezcan con el tiempo.

Consejos para solucionar problemas

Si el puente no desaparece, comprueba los posibles problemas a continuación: Problema: Las partes desaparecen demasiado rápido o se han ido al iniciar.

• Dependiendo de lo rápido que se cargue tu personaje en la experiencia, las primeras partes ya pueden ser invisibles. Para hacer frente a esto, agregue una pequeña espera, como task.wait(2) , al comienzo del script.

Codificación del Segundo Círculo

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

1. Después del primer bucle, agregue 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. En tu propio , intenta codificar un segundo para el bucle que haga que la ruta sea utilizable de nuevo cambiando la propiedad CanCollide de cada parte a true y Transparencia a 0. Cuando termines, comprueba tu trabajo contra el código de abajo.

   -- 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 partes no ancladas caerán a través de la placa base cuando CanCollide sea falso. Si las partes no reaparecen y no hay errores de salida, ancla las partes y prueba de nuevo.

3. Prueba el proyecto para confirmar que una vez que todas las partes desaparezcan, volverán.

Repetir con un bucle de un tiempo

Las partes desaparecen y reaparecen, pero solo una vez. Para que el código se siga repitiendo, anida todo el código dentro de un bucle.

1. En la parte inferior del script, crea un nuevo bucle while true do. Luego, mueve ambos para los bucles al bucle while.

   while true do
      -- Haz que una parte desaparezca del conjunto 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)
   
   	-- 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. Comprueba que una vez que todas las partes desaparezcan, reaparecerán.

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
	-- Haz que una parte desaparezca del conjunto 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)

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

Arrays y ipairs ()

ipairs() se usa con matrices . La "i" en ipairs() significa "index." 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á agregando rápidamente partículas a una carpeta completa de piezas.

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

2. En ServerScriptService, cree un nuevo script y haga referencia a 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 conjunto que enumera las piezas en la carpeta de piezas
   local partsArray = partsFolder:GetChildren()

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

   scriptCompletado
   -- Obtiene un conjunto que enumera las piezas en la carpeta de piezas
   local partsArray = partsFolder:GetChildren()
   
   -- Añade partículas a todas las partes del matriz/lista
   for index, part in ipairs(partsArray) do
   	local particles = Instance.new("ParticleEmitter")
   	particles.Parent = part
   end

Reproduce la prueba y mira las partículas flotar desde cada parte de la carpeta.

Resumen

Los bucles se pueden combinar con matrices para trabajar con cualquier número de valores rápidamente. Si desea tener control exacto sobre lo que sucede con algunas partes y en qué orden, una matriz debe estar codificada con valores específicos.

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