Ciclos e arrays

Arrays podem ser combinados com loops, 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 com que um array de peças pegue Iniciar / executar.

Para explorar o looping através de arrays, crie um caminho de ponte desaparecente onde as peças são colocadas em um array e depois feitas desaparecer uma por uma.

Iteração através de um matriz / lista

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

Crie três partes. Nomeie as partes na ordem em que devem desaparecer, Part1, Part2, Part3.
No ServerScriptService, insira um novo script e crie um array para armazenar as peças.
```
local pathArray = {
}
```

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


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

Use um ciclo for com um matriz / lista

Use um ciclo for para percorrer o array e controlar quão rápido as peças devem desaparecer na ordem em que as peças são indexadas dentro do matriz / lista.

Para controlar com que frequência uma peça 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.Part1,
	workspace.Part2,
	workspace.Part3
}
```
Constantes são variáveis que não devem ser alteradas por qualquer outro código no script.Eles provavelmente precisam de ajuste e são colocados no topo do script em ALL_CAPS para torná-los fáceis de detectar.
Crie um ciclo for com o seguindo: Início: partIndex = 1 , o índice do primeiro valor no matriz / lista. Fim: #pathArray, o tamanho desse matriz / lista.
```
for partIndex = 1, #pathArray  do

end
```

Então há um atraso antes que uma parte desapareça, no loop, adicione um task.wait() usando VANISH_RATE.


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

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


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

Verifique se partes do caminho desaparecem ao longo do tempo.

Dicas de solução de problemas

Se a ponte não desaparecer, verifique as possíveis questões abaixo: Problema: Peças desaparecem muito rápido ou todas se foram no iniciar.

Dependendo de quão rápido o seu personagem carrega na experiência, as primeiras partes já podem ser invisíveis.Para abordar isso, adicione uma pequena espera, como task.wait(2) , no início do script.

Code o segundo loop

No momento, as peças desaparecem para sempre.Para fazê-los reaparecer, crie um segundo para ciclo que passará por cada parte e instantaneamente tornará cada peça caminhável.

Após o primeiro loop, 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)

Em seu próprio , tente codificar um segundo para loop que faça o caminho novamente utilizável alterando a propriedade CanCollide de cada parte para verdadeiro e a transparência para 0.Quando terminar, verifique seu trabalho contra o código abaixo.


-- Redefina o caminho fazendo com que todas as peças sejam novamente caminháveis
for partIndex = 1, #pathArray do
   local whichPart = pathArray[partIndex]
   whichPart.CanCollide = true
   whichPart.Transparency = 0
end

Peças não ancoradas cairão através da placa base quando CanCollide for falso.Se as peças não estão reaparecendo e não há erros de saída, ancore as peças e teste novamente.

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

Repita com um loop while

As peças desaparecem e reaparecem, mas apenas uma vez. Para fazer com que o código continue a repetir, embrulhe todo o código dentro de um loop while.

Na parte inferior do script, crie um novo ciclo while verdadeiro. Então, mova ambos para os loops no ciclo 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 um segundo antes de fazer o caminho reaparecer
	task.wait(1)

	-- Redefina o caminho fazendo com que todas as peças sejam novamente caminháveis
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Verifique se, uma vez que todas as peças desaparecem, elas reaparecem.

Uma versão final do projeto pode ser baixada.

scriptconcluído
local VANISH_RATE = 1.0

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

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 um segundo antes de fazer o caminho reaparecer
	task.wait(1.0)

	-- Redefina o caminho fazendo com que todas as peças sejam novamente caminháveis
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Arranjos e ipairs()

ipairs() é usado com arrays .O "i" em ipairs() representa "índice". ipairs() pode ser usado para repetir rapidamente uma operação em muitos objetos, como, digamos, uma pasta cheia de peças.

Isso será demonstrado adicionando rapidamente partículas a uma pasta inteira de peças.

No Espaço de Trabalho, crie uma pasta chamada PartsFolder. Adicione quantas peças você quiser.
No ServerScriptService, crie um novo script e referencie o diretório.

Use GetChildren() para obter automaticamente um array que lista todos os objetos na pasta.


local partsFolder = workspace.PartsFolder

-- Obtém um array que lista as peças no Arquivo de Peças
local partsArray = partsFolder:GetChildren()

Use in ipairs(ArrayToUse) com o loop for para percorrer a matriz de partes e adicionar partículas

scriptconcluído
-- Obtém um array que lista as peças no Arquivo de Peças
local partsArray = partsFolder:GetChildren()

-- Adiciona partículas a cada parte no matriz / lista
for index, part in ipairs(partsArray) do
	local particles = Instance.new("ParticleEmitter")
	particles.Parent = part
end

Teste e observe as partículas flutuarem de cada parte na pasta.

Sumário

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

Para trabalhar com muitas partes onde a ordem não importa, GetChildren() pode criar um array de filhos de um Objeto.Ao utilizar ipairs(), a lista pode ser iterada rapidamente sem conhecer o tamanho do matriz / lista.