Cicli e array

Gli array possono essere combinati con cicli, come while e for, per ripetere lo stesso codice per ogni valore indicizzato. Ad esempio, teletrasportare ogni giocatore in un array in un nuovo luogo o far prendere fuoco a un array di parti.

Per esplorare l'iterazione attraverso gli array, crea un percorso di ponte che scompare dove le parti sono inserite in un array e poi fatte svanire una per una.

Cicla attraverso un array

Per il progetto, trova o crea un insieme di tre parti da far scomparire. Le parti devono essere tutte ancorate.

Crea tre parti. Nomina le parti nell'ordine in cui dovrebbero scomparire, Parte1, Parte2, Parte3.
In ServerScriptService, inserisci un nuovo script e crea un array per memorizzare le parti.
```
local pathArray = {
}
```

Su una singola riga ciascuna, digita il nome delle parti nell'ordine in cui dovrebbero scomparire. Usare una nuova riga per ciascun valore rende più facile la lettura.


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

Usa un ciclo for con un array

Usa un ciclo for per scorrere l'array e controllare quanto velocemente le parti dovrebbero scomparire nell'ordine in cui le parti sono indicizzate all'interno dell'array.

Per controllare quanto spesso una parte scompare in secondi, crea una variabile chiamata VANISH_RATE. Per i test, è meglio mantenerla su un numero ridotto.
```
local VANISH_RATE = 1.5

local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3
}
```
Le costanti sono variabili che non dovrebbero essere cambiate da nessun altro codice nello script. È probabile che debbano essere regolate e sono messe in cima allo script in ALL_CAPS per renderle facilmente individuabili.
Crea un ciclo for con i seguenti parametri: Inizio: partIndex = 1, l'indice del primo valore nell'array. Fine: #pathArray, la dimensione di quell'array.
```
for partIndex = 1, #pathArray  do

end
```

Affinché ci sia un ritardo prima che una parte scompaia, nel ciclo, aggiungi un task.wait() utilizzando VANISH_RATE.


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

Per far scomparire una parte, crea una nuova variabile chiamata whichPart e impostala uguale a pathArray[partIndex]. Poi, per far scomparire quella parte, imposta la sua proprietà CanCollide su false e Transparency su 1.


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

Controlla che le parti del percorso scompaiano nel tempo.

Suggerimenti per la risoluzione dei problemi

Se il ponte non scompare, controlla i possibili problemi qui sotto:

Problema: Le parti scompaiono troppo velocemente o sono tutte sparite all'inizio.

A seconda di quanto velocemente il tuo personaggio si carica nell'esperienza, le prime parti potrebbero essere già invisibili. Per affrontare questo, aggiungi un breve ritardo, come task.wait(2), all'inizio dello script.

Codifica il secondo ciclo

Attualmente, le parti scompaiono per sempre. Per farle riapparire, crea un secondo ciclo for che scorrerà ciascuna parte e renderà immediatamente ciascun pezzo percorribile.

Dopo il primo ciclo, aggiungi un task.wait() per creare un breve ritardo prima che il percorso riappaia.


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

task.wait(1)

Da solo, prova a codificare un secondo ciclo for che rende di nuovo utilizzabile il percorso cambiando la proprietà CanCollide di ciascuna parte su true e Transparency su 0. Una volta terminato, controlla il tuo lavoro rispetto al codice qui sotto.


-- Ripristina il percorso rendendo tutte le parti di nuovo percorribili
for partIndex = 1, #pathArray do
   local whichPart = pathArray[partIndex]
   whichPart.CanCollide = true
   whichPart.Transparency = 0
end

Le parti non ancorate cadranno attraverso la base quando CanCollide è false. Se le parti non riappaiono e non ci sono errori nell'Output, ancore le parti e riprova.

Testa il progetto per confermare che una volta che tutte le parti scompaiono, ritornano.

Ripeti con un ciclo while

Le parti scompaiono e riappaiono, ma solo una volta. Per far sì che il codice continui a ripetersi, annida tutto il codice all'interno di un ciclo while.

In fondo allo script, crea un nuovo ciclo while true do. Poi, sposta entrambi i cicli for all'interno del ciclo while.


while true do
   -- Fai scomparire una parte dall'array in ordine
	for partIndex = 1, #pathArray  do
		task.wait(VANISH_RATE)
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = false
		whichPart.Transparency = 1
	end

	-- Aspetta un secondo prima di far riapparire il percorso
	task.wait(1)

	-- Ripristina il percorso rendendo tutte le parti di nuovo percorribili
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Controlla che, una volta che tutte le parti scompaiono, riappaiano.

Una versione completata del progetto può essere scaricata.

Script completato
local VANISH_RATE = 1.0

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

while true do
	-- Fai scomparire una parte dall'array in ordine
	for partIndex = 1, #pathArray  do
		task.wait(VANISH_RATE)
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = false
		whichPart.Transparency = 1
	end

	-- Aspetta un secondo prima di far riapparire il percorso
	task.wait(1.0)

	-- Ripristina il percorso rendendo tutte le parti di nuovo percorribili
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Arrays e ipairs()

ipairs() è usato con array. La "i" in ipairs() sta per "indice." Le ipairs() possono essere usate per ripetere rapidamente un'operazione su molti oggetti, come, per esempio, una cartella piena di parti.

Questo sarà dimostrato aggiungendo rapidamente particelle a un'intera cartella di parti.

In Workspace, crea una cartella chiamata PartsFolder. Aggiungi quante più parti vuoi.
In ServerScriptService, crea un nuovo script e fai riferimento alla cartella.

Usa GetChildren() per ottenere automaticamente un array che elenchi tutti gli oggetti nella cartella.


local partsFolder = workspace.PartsFolder

-- Ottiene un array che elenca le parti in PartsFolder
local partsArray = partsFolder:GetChildren()

Usa in ipairs(ArrayToUse) con il ciclo for per scorrere partsArray e aggiungere particelle.

Script completato
-- Ottiene un array che elenca le parti in PartsFolder
local partsArray = partsFolder:GetChildren()

-- Aggiunge particelle a ogni parte nell'array
for index, part in ipairs(partsArray) do
	local particles = Instance.new("ParticleEmitter")
	particles.Parent = part
end

Gioca e osserva le particelle che fluttuano verso l'alto da ogni parte nella cartella.

Riepilogo

I cicli possono essere combinati con gli array per lavorare rapidamente con qualsiasi numero di valori. Se desideri avere un controllo esatto su cosa succede a poche parti e in quale ordine, un array deve essere codificato a mano con valori specifici.

Per lavorare con molte parti dove l'ordine non importa, GetChildren() può creare un array dei figli di un oggetto. Utilizzando ipairs(), l'elenco può essere rapidamente iterato senza conoscere la dimensione dell'array.