Laços e arrays | Documentação - Central de Criadores Roblox

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 o looping através de arrays, crie um caminho de ponte que desaparece onde partes são colocadas em um array e, em seguida, fazem-se desaparecer uma a uma.

Percorra um array

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

Crie três partes. Nomeie as partes na ordem em que devem desaparecer: Parte1, Parte2, Parte3.
No ServerScriptService, insira um novo script e crie um array para armazenar as partes.
```
local pathArray = {
}
```

Em uma única linha cada, digite o nome das partes na ordem em que devem desaparecer. Usar uma nova linha para cada valor facilita a leitura.


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.

Para controlar com que frequência uma parte desaparece em segundos, crie uma variável chamada VANISH_RATE. Para testar, é 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 de ajustes e são colocadas no topo do script em ALL_CAPS para facilitar a visualização.
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
```

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


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

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


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

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 desde o início.

Dependendo de quão rapidamente seu personagem carrega na experiência, 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 utilizável.

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)

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 verdadeira e Transparency para 0. Quando estiver terminado, verifique seu trabalho em relação ao código abaixo.


-- Redefine o caminho tornando todas as partes utilizá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 falsa. Se as partes não estão reaparecendo, e não há erros de Output, ancore as partes e teste novamente.

Teste o projeto para confirmar que, uma vez que todas as partes desapareçam, elas voltem.

Repita com um laço while

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

Na parte inferior do script, crie um novo laço while true do. Em seguida, movimente 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

	-- Espere por um segundo antes de fazer o caminho reaparecer
	task.wait(1)

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

Verifique se, uma vez que todas as partes desapareçam, elas reaparecem.

Uma versão finalizada do projeto pode ser baixada.

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

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

	-- Redefine o caminho tornando todas as partes utilizá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". A função ipairs() pode ser usada para repetir rapidamente uma operação em muitos objetos, como, por exemplo, uma pasta cheia de partes.

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

No Workspace, crie uma pasta chamada PartsFolder. Adicione quantas partes quiser.
No ServerScriptService, crie um novo script e faça referência à pasta.

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

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 a partir de cada parte na pasta.

Resumo

Laços podem ser combinados com arrays para trabalhar rapidamente com qualquer número de valores. Se você deseja ter controle exato sobre o que acontece com algumas partes e em que ordem, um array deve ser codificado manualmente 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 conhecer o tamanho do array.