Loop e Arrays | Documentazione - Roblox Hub Creatori

Gli array possono essere combinati con i loop, come mentre e per , per ripetere lo stesso codice per ciascun valore indexato. Ad esempio, teletrasportare ogni giocatore in un array in un nuovo luogo o fare un array di parti prendere Lanciare.

Per esplorare il looping attraverso gli array, crea un percorso di ponte scomparso in cui le parti vengono inserite in un array e poi create per scomparire uno per uno.

Looping attraverso un array

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

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

Su una singola linea, per ciascuna parte, digita il suo nome nell'ordine in cui dovrebbe scomparire. Usando una nuova linea per ciascun valore rende più facile da leggere.


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

Uso di un for Loop con un Array

Usa un for loop per passare attraverso l' array e controllare quanto velocemente le parti dovrebbero scomparire nell'ordine in cui le parti sono索引ate all' vettore.

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

local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3
}
```
Costanti sono variabili che non dovrebbero essere modificati da nessun altro codice nello script. Sono probabilmente necessarie di essere regolate e vengono poste nella parte superiore dello script in ALL_CAPS per renderle facili da individuare.
Crea un for loop con il Seguendo: Inizio: partIndex = 1 , l'indice del primo valore nell' vettore. Fine: 1> #pathArray1> , la dimensione di quell' vettore.
```
for partIndex = 1, #pathArray  do

end
```

C'è quindi un ritardo prima che una parte scompaia, in loop, aggiungi un task.wait() utilizzando VANISH_RATE .


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

Per ottenere una parte che scompaia, crea una nuova variabile chiamata whichPart e imposta pari a partsArray[partIndex] . Quindi, per scompaionare quella parte, imposta la sua proprietà CanCollide su false e la sua trasparenza 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 siano scomparse nel tempo.

Risolvere i problemi

Se il ponte non scompare, controlla i possibili problemi di seguito: Problema: Le parti scompaiono troppo velocemente o sono tutte andate all'Iniziare, cominciare.

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

Codice del secondo loop

In questo momento, le parti scompaiono per sempre. Per renderle riapparire, crea un secondo per il loop che passa attraverso ciascuna parte e rende istantaneamente ogni pezzo camminabile.

Dopo il primo loop, aggiungi un task.wait() per creare un breve ritardo prima che la strada riapparirà.


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

task.wait(1)

Su tua conia , prova a codificare un secondo per il loop che rende nuovamente il percorso utilizzabile modificando la proprietà Collisioni di ciascuna parte a verità e trasparenza di 0. Quando hai finito, controlla il tuo lavoro contro il codice sottostante.


-- Ripristina il percorso rendendo nuovamente camminabili tutte le parti
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 uscita, ancorare le parti e testare di nuovo.

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

Ripetere con un While Loop

Le parti scompaiono e riappaiono, ma solo una volta. Per mantenere il codice a ripetere, annida tutto il codice in un while loop.

Alla fine dello script, crea un nuovo while true do loop. Quindi, spostare entrambi per i loop in while loop.


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

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

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

Assicurati che una volta che tutte le parti scompaiono, siano reapparire.

Una versione completa 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

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

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

Matrici e ipairs()

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

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

In Area di lavoro, crea una cartella chiamata PartsFolder. Aggiungi tutte le parti che ti piace.
In ServerScriptService, crea uno script nuovo e fai riferimento alla cartella.

Usa GetChildren() per ottenere automaticamente un elenco di oggetti nella cartella.


local partsFolder = workspace.PartsFolder

-- Ottiene un elenco di parti in PartsFolder
local partsArray = partsFolder:GetChildren()

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

scriptcompletato
-- Ottiene un elenco di parti in PartsFolder
local partsArray = partsFolder:GetChildren()

-- Aggiunge parti all' vettore
for index, part in ipairs(partsArray) do
	local particles = Instance.new("ParticleEmitter")
	particles.Parent = part
end

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

Panoramica

I loop possono essere combinati con gli array per lavorare con qualsiasi numero di valori rapidamente. Se vuoi avere il controllo esatto su ciò che accade a alcune parti e in quale ordine, un array deve essere hard-coded con valori specifici.

Per lavorare con molte parti in cui l'ordine non importa, GetChildren() può creare un'arrangione di figli di un oggetto. Utilizzando ipairs(), la lista può essere itérata rapidamente senza conoscere la dimensione dell'vettore.