Laços e arrays

Arrays podem ser combinados com laços, como while e for, para repetir o mesmo código para cada valor indexado. Por exemplo, teletransportar cada jogador em um array para um novo lugar ou fazer um array de partes pegar fogo.

Para explorar a iteração através de arrays, crie um caminho de ponte que desaparece, onde as partes são colocadas em um array e depois feitas para desaparecer uma a uma.

Percorrer um array

Para o projeto, encontre ou crie um conjunto de três partes para fazer desaparecer. As partes devem estar todas ancoradas.

1. Crie três partes. Nomeie as partes na ordem em que devem desaparecer: Parte1, Parte2, Parte3.

2. No ServerScriptService, insira um novo script e crie um array para armazenar as partes.

   local pathArray = {
   }

3. Em uma única linha cada, digite o nome das partes na ordem em que devem desaparecer. Usar uma nova linha para cada valor torna mais fácil de ler.

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

Use um laço for com um array

Use um laço for para percorrer o array e controlar quão rápido as partes devem desaparecer na ordem em que as partes estão indexadas dentro do array.

1. Para controlar com que frequência uma parte desaparece em segundos, crie uma variável chamada VANISH_RATE. Para testes, é melhor mantê-la em um número pequeno.

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

   Constantes são variáveis que não devem ser alteradas por nenhum outro código no script. Elas provavelmente precisarão ser ajustadas e são colocadas no topo do script em ALL_CAPS para torná-las fáceis de identificar.

2. Crie um laço for com o seguinte: Início: partIndex = 1, o índice do primeiro valor no array. Fim: #pathArray, o tamanho desse array.

   for partIndex = 1, #pathArray  do
   
   end

3. Para que haja um atraso antes de uma parte desaparecer, no laço, adicione um task.wait() usando VANISH_RATE.

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

4. Para fazer uma parte desaparecer, crie uma nova variável chamada whichPart e defina-a igual a pathArray[partIndex]. Então, para fazer essa parte desaparecer, defina a propriedade CanCollide como false e Transparency como 1.

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

5. Verifique se as partes do caminho desaparecem ao longo do tempo.

Dicas de solução de problemas

Se a ponte não desaparecer, verifique os possíveis problemas abaixo:

Problema: As partes desaparecem muito rápido ou já estão todas desaparecidas no início.

• Dependendo de quão rápido seu personagem carrega no jogo, as primeiras partes podem já estar invisíveis. Para resolver isso, adicione uma pequena espera, como task.wait(2), no início do script.

Codifique o segundo laço

Neste momento, as partes desaparecem para sempre. Para fazê-las reaparecer, crie um segundo laço for que percorrerá cada parte e instantaneamente tornará cada peça caminhável.

1. Após o primeiro laço, adicione um task.wait() para criar um pequeno atraso antes que o caminho reapareça.

   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 conta própria, tente codificar um segundo laço for que torne o caminho utilizável novamente, mudando a propriedade CanCollide de cada parte para true e Transparency para 0. Quando terminar, verifique seu trabalho com o código abaixo.

   -- Redefine o caminho tornando todas as partes caminháveis novamente
   for partIndex = 1, #pathArray do
      local whichPart = pathArray[partIndex]
      whichPart.CanCollide = true
      whichPart.Transparency = 0
   end

   Partes não ancoradas cairão através da base quando CanCollide for false. Se as partes não estão reaparecendo, e não há erros de Output, ancore as partes e teste novamente.

3. Teste o projeto para confirmar que, uma vez que todas as partes desaparecem, elas voltam.

Repita com um laço while

As partes desaparecem e reaparecem, mas apenas uma vez. Para fazer o código continuar repetindo, aninhe todo o código dentro de um laço while.

1. Na parte inferior do script, crie um novo laço while true do. Então, mova ambos os laços for para dentro do laço while.

   while true do
      -- Faça uma parte desaparecer do array em ordem
   	for partIndex = 1, #pathArray  do
   		task.wait(VANISH_RATE)
   		local whichPart = pathArray[partIndex]
   		whichPart.CanCollide = false
   		whichPart.Transparency = 1
   	end
   
   	-- Aguarde um segundo antes de fazer o caminho reaparecer
   	task.wait(1)
   
   	-- Redefina o caminho tornando todas as partes caminháveis novamente
   	for partIndex = 1, #pathArray do
   		local whichPart = pathArray[partIndex]
   		whichPart.CanCollide = true
   		whichPart.Transparency = 0
   	end
   end

2. Verifique se, uma vez que todas as partes desaparecem, elas reaparecem.

Uma versão finalizada do projeto pode ser baixada.

local VANISH_RATE = 1.0

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

while true do
	-- Faça uma parte desaparecer do array em ordem
	for partIndex = 1, #pathArray  do
		task.wait(VANISH_RATE)
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = false
		whichPart.Transparency = 1
	end

	-- Aguarde um segundo antes de fazer o caminho reaparecer
	task.wait(1.0)

	-- Redefina o caminho tornando todas as partes caminháveis novamente
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Arrays e ipairs()

ipairs() é usado com arrays. O "i" em ipairs() significa "índice". ipairs() pode ser usado para repetir rapidamente uma operação em muitos objetos, como, por exemplo, uma pasta cheia de partes.

Isso será demonstrado adicionando rapidamente partículas a uma pasta inteira de partes.

1. No Workspace, crie uma pasta chamada PartsFolder. Adicione quantas partes quiser.

2. No ServerScriptService, crie um novo script e faça referência à pasta.

3. Use GetChildren() para obter automaticamente um array listando todos os objetos na pasta.

   local partsFolder = workspace.PartsFolder
   
   -- Obtém um array listando as partes na PartsFolder
   local partsArray = partsFolder:GetChildren()

4. Use in ipairs(ArrayToUse) com o laço for para percorrer partsArray e adicionar partículas.

   Script completo

   -- Obtém um array listando as partes na PartsFolder
   local partsArray = partsFolder:GetChildren()
   
   -- Adiciona partículas a cada parte no array
   for index, part in ipairs(partsArray) do
   	local particles = Instance.new("ParticleEmitter")
   	particles.Parent = part
   end

Teste e veja as partículas flutuando de cada parte na pasta.

Resumo

Laços podem ser combinados com arrays para trabalhar rapidamente com qualquer número de valores. Se você quiser ter controle exato sobre o que acontece com algumas partes e em que ordem, um array deve ser codificado com valores específicos.

Para trabalhar com muitas partes onde a ordem não importa, GetChildren() pode criar um array dos filhos de um objeto. Utilizando ipairs(), a lista pode ser rapidamente iterada sem saber o tamanho do array.