Cicli e array

Gli array possono essere combinati con i loop, come while e per , per ripetere lo stesso codice per ogni valore indicizzato.Ad esempio, teletrasportare ogni giocatore in un array in un nuovo luogo o fare in modo che un array di parti prenda Lanciare.

Per esplorare il ciclo attraverso gli array, crea un percorso ponte scomparso in cui le parti vengono posizionate in un array e poi fatte sparire una per una.

Loop attraverso un vettore

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

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

Su una singola linea per ciascuno, digita il nome delle parti nell'ordine in cui dovrebbero scomparire. L'uso di una nuova linea per ciascun valore rende più facile da leggere.


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

Usa un ciclo while con un vettore

Usa un ciclo while per passare attraverso l'array e controllare quanto velocemente le parti dovrebbero scomparire nell'ordine in cui sono indicate nell'vettore.

Per controllare con quale frequenza una parte scompare in secondi, crea una variabile chiamata VANISH_RATE . Per i test, è meglio mantenerla a un piccolo numero.
```
local VANISH_RATE = 1.5

local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3
}
```
Le costanti sono variabili che non dovrebbero essere modificate da nessun altro codice nello script.È probabile che debbano essere regolati e vengono messi in cima allo script in ALL_CAPS per renderli facili da individuare.
Crea un ciclo while con quanto Seguendo: Inizio: partIndex = 1 , l'indice del primo valore nell'vettore. Fine: #pathArray , la dimensione di quell'vettore.
```
for partIndex = 1, #pathArray  do

end
```

Quindi c'è 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 sparire una parte, crea una nuova variabile chiamata whichPart e impostala uguale a partsArray[partIndex] .Quindi, per far sparire quella parte, imposta la sua proprietà CanCollide a false e Transparency a 1.


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

Controlla che parti del percorso scompaiono nel tempo.

Suggerimenti per la risoluzione dei problemi

Se il ponte non scompare, controlla i problemi possibili qui sotto: Problema: Le parti scompaiono troppo rapidamente o vanno tutte via all'Iniziare, cominciare.

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

Codifica il secondo ciclo

Al momento, le parti scompaiono per sempre.Per farli riapparire, crea un secondo ciclo while che passerà attraverso ciascuna parte e renderà istantaneamente ogni 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 while che renda nuovamente utilizzabile il percorso cambiando la proprietà CanCollide di ciascuna parte a vero e la trasparenza a 0.Quando hai finito, controlla il tuo lavoro contro il codice qui sotto.


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

Le parti non ancorate cadranno attraverso la piastra di base quando CanCollide è falso.Se le parti non riappaiono e non ci sono errori di output, ancorare le parti e testare di nuovo.

Prova il progetto per confermare che una volta che tutte le parti scompariranno, Indietro.

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.

Nella parte inferiore dello script, crea un nuovo while true loop. Quindi, sposta entrambi per i cicli nel ciclo while.


while true do
   -- Fai sparire 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

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

	-- Ripristina il percorso rendendo nuovamente le parti 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, riappaiono.

Una versione finale del progetto può essere scaricata.

scriptcompletato
local VANISH_RATE = 1.0

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

while true do
	-- Fai sparire 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

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

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

Array e ipairs()

ipairs() viene utilizzato con array .Il "i" in ipairs() sta per "index." ipairs() può essere utilizzato per ripetere rapidamente un'operazione su molti oggetti, come, per esempio, una cartella piena di parti.

Questo sarà dimostrato aggiungendo rapidamente particelle a un intero folder di parti.

Nell'area di lavoro, crea una cartella chiamata PartsFolder. Aggiungi quanti più pezzi ti piaccia.
In ServerScriptService, crea un nuovo script e fa riferimento alla cartella.

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


local partsFolder = workspace.PartsFolder

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

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

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

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

Prova e guarda le particelle fluttuare da ogni parte nella cartella.

Sommariamente

I cicli possono essere combinati con gli array per lavorare con qualsiasi numero di valori rapidamente.Se vuoi avere un controllo preciso su ciò che accade a poche parti e in che ordine, un array deve essere codificato a mano con valori specifici.

Per lavorare con molte parti in cui l'ordine non ha importanza, GetChildren() può creare un array di figli di un oggetto.Utilizzando ipairs() , la lista può essere iterata rapidamente senza conoscere la dimensione dell'vettore.