Ciclos y Matrices

Los arreglos se pueden combinar con bucles, como mientras y por , 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 ponga en desencadenar.

Para explorar el looping a través de los arrays, crea un camino de puente desapariciendo donde las partes se colocan en un array y luego se hacen para desaparecer uno a uno.

Ciclo a través de un matriz

Para el proyecto, busque o cree un conjunto de tres partes para hacer desaparecer. Las partes deben tener todas las anclas.

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

2. En ServerScriptService, introduce un nuevo script y crea un nuevo array para almacenar las partes.

   local pathArray = {
   }

3. En una sola línea cada, 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 for Loop con un Array

Usa un for loop para ir a través del array y controlar con qué rapidez las partes deben desaparecer en el orden en que las partes están indexadas dentro del matriz/lista.

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

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

   Constantes son variables que no deben ser cambiadas por ningún otro código en el script. Están probablemente sujetas a ajustar y se colocan en la parte superior del script en ALL_CAPS para hacerlas fáciles de encontrar.

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

   for partIndex = 1, #pathArray  do
   
   end

3. Así que hay un retraso antes de que desaparezca una parte, en el ciclo, agrega un task.wait() usando VANISH_RATE .

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

4. Para obtener una parte que desaparezca, crea una nueva variable llamada whichPart y establece que sea igual a partsArray[partIndex] . Luego, para desaparecer esa parte, establece su propiedad CanCollide a false y su propiedad 1> Transparency1> a 1.

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

5. Asegúrese de que algunas de las partes del camino desaparezcan con el tiempo.

Consejos de solución de problemas

Si el puente no desaparece, verifique los posibles problemas a continuación: Problema: Las partes desaparecen demasiado rápido o están todas en el iniciar.

• Dependiendo de la rapidez con la que se carga tu personaje en la experiencia, las primeras partes pueden ser invisibles. Para abordar esto, añade un pequeño espacio de espera, como task.wait(2), al comienzo del script.

Código del segundo bucle

En este momento, las partes desaparecen para siempre. Para hacer que reaparezcan, crea una segunda para la que pasará por cada parte y hará que cada pieza sea caminable.

1. Después de la primera vuelta, agregue un task.wait() para crear un breve retraso antes de que la ruta 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 para la repetición que hace que el camino sea usable de nuevo al cambiar la propiedad CanCollide de cada parte a true y Transparency a 0. Cuando termines, comprueba tu trabajo contra el código a continuación.

   -- Restablece 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 es 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 desaparecen, volver.

Repitiendo con un bucle mientras

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

1. En la parte inferior del script, crea un nuevo mientras es cierto que se repite. Luego, mueve ambos para en la ronda de repetición.

   while true do
      -- Haga que una parte desaparezca del array 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 hacer que el camino reaparezca
   	task.wait(1)
   
   	-- Restablece 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úrese de que una vez que todas las partes desaparecen, reaparecen.

Una versión final del proyecto se puede descargar.

scriptcompletado
local VANISH_RATE = 1.0

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

while true do
	-- Haga que una parte desaparezca del array 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 hacer que el camino reaparezca
	task.wait(1.0)

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

Matrices y ipairs()

ipairs() se usa con arrays . El "i" en ipairs() significa "索引". Los "ipairs()" pueden usarse para repetir rápidamente una operación en muchos objetos, como, digamos, un directorio lleno de partes.

Esto se mostrará agregando rápidamente partículas a una carpeta completa de partes.

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

2. En ServerScriptService, crea un nuevo script y referencia el directorio.

3. Usa GetChildren() para obtener automáticamente un listado de 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 for loop para pasar por partsArray y agregar partículas.

   scriptcompletado
   -- Obtiene un arreglo 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

Pruebe y vea las partículas flotar de cada parte en la carpeta.

Resumen

Las cadenas se pueden combinar con matices para trabajar con cualquier número de valores rápidamente. Si desea tener un control exacto de lo que sucede con algunas partes y en qué orden, un matiz debe estar codificado con valores específicos.

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