Cicli e array

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 il ciclo attraverso gli array, crea un percorso di ponte che scompare dove le parti vengono inserite in un array e poi fatte svanire una ad una.

Ciclo attraverso un array

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

1. Crea tre parti. Nomina le parti nell'ordine in cui devono scomparire, Part1, Part2, Part3.

2. In ServerScriptService, inserisci un nuovo script e crea un array per memorizzare le parti.

   local pathArray = {
   }

3. Su una singola riga ciascuna, digita il nome delle parti nell'ordine in cui devono scomparire. Usare una nuova riga per ogni 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 attraversare l'array e controllare quanto velocemente le parti devono scomparire nell'ordine in cui le parti sono indicizzate all'interno dell'array.

1. Per controllare quanto spesso una parte scompare in secondi, crea una variabile chiamata VANISH_RATE. Per testare, è meglio mantenerla a un numero basso.

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

   Costanti sono variabili che non dovrebbero essere cambiate da nessun altro codice nello script. È probabile che necessitino di aggiustamenti e sono messe all'inizio dello script in ALL_CAPS per renderle facili da individuare.

2. 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

3. 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

4. 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

5. 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 scomparse all'inizio.

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

Codifica il secondo ciclo

In questo momento, le parti scompaiono per sempre. Per farle riapparire, crea un secondo ciclo for che attraverserà ogni parte e renderà ogni pezzo immediatamente calpestabile.

1. 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)

2. Da solo, prova a codificare un secondo ciclo for che rende di nuovo utilizzabile il percorso cambiando la proprietà CanCollide di ogni parte su true e Transparency su 0. Quando hai finito, controlla il tuo lavoro con il codice qui sotto.

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

   Le parti non ancorate cadranno attraverso il baseplate quando CanCollide è false. Se le parti non riappaiono e non ci sono errori in Output, ancorare le parti e testare di nuovo.

3. Testa il progetto per confermare che una volta che tutte le parti scompaiono, tornano 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.

1. 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 di nuovo tutte le parti calpestabili
   	for partIndex = 1, #pathArray do
   		local whichPart = pathArray[partIndex]
   		whichPart.CanCollide = true
   		whichPart.Transparency = 0
   	end
   end

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

Una versione completata del progetto può essere scaricata.

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 di nuovo tutte le parti calpestabili
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Array e ipairs()

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

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

1. In Workspace, crea una cartella chiamata PartsFolder. Aggiungi quante più parti desideri.

2. In ServerScriptService, crea un nuovo script e fai riferimento alla cartella.

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

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

4. Usa in ipairs(ArrayToUse) con il ciclo for per attraversare 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 guarda le particelle fluttuare 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.