Cicli nidificati | Documentazione

Nidificare i cicli ti consente di ripetere compiti a gruppi. Ad esempio, cuocere tre lotti di sei cupcake, o assegnare armi ai giocatori di due squadre.

Come funzionano i cicli nidificati

Quando i cicli sono nidificati, gli script vengono eseguiti riga per riga fino a raggiungere il ciclo successivo. Il ciclo interno verrà eseguito finché non è soddisfatta la sua condizione, prima di tornare al ciclo esterno.

Logica del ciclo nidificato

Il seguente diagramma mostra i passaggi che un ciclo compie.

Il ciclo esterno: il codice viene eseguito riga per riga fino a raggiungere il ciclo interno.
Il ciclo esterno: il codice viene eseguito riga per riga fino a raggiungere il ciclo interno.
Il ciclo esterno: il codice viene eseguito riga per riga fino a raggiungere il ciclo interno.

Esempio di ciclo nidificato

I cicli nidificati possono sembrare piuttosto astratti, quindi un esempio visivo può aiutare. Per questo esercizio, copia e incolla uno script di esempio e eseguilo in Studio. Questo script creerà torri di parti. Il ciclo esterno controllerà quanti pezzi creare, mentre il ciclo interno creerà il lotto reale.

Crea un nuovo script in ServerScriptService chiamato PartMaker. Copia il codice qui sotto.


local numberOfBatches = 7
local partsPerBatch = 5
local partsMade = 0

-- Crea un singolo cubo
local function createPart()
  local part = Instance.new("Part")
  part.Size = Vector3.new(2, 2, 2)
  part.CFrame = CFrame.new(20, 0, 20)
  part.Color = currentColor
  part.Parent = workspace
end

-- Ciclo esterno
for partBatch = 1, numberOfBatches do
  print("Ciclo esterno superiore: lotto di parti " .. partBatch)
  currentColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))

  -- Ciclo interno
  for partNumber = 1, partsPerBatch do
    createPart()
    print("Ciclo interno: parte " .. partNumber)
    partsMade += 1
    task.wait(0.5)
  end

  print("Ciclo esterno inferiore: " .. partsMade .. " parti create finora.")

  task.wait(2)
end

Guarda mentre lo script genera un lotto diverso di parti colorate. Dopo aver completato un lotto, si fermerà per 2 secondi. La dichiarazione print nel ciclo esterno verrà eseguita solo una volta per ciclo interno completato.

Torre del ciclo for nidificato

Ogni ciclo ha il proprio insieme di codice, quindi può essere responsabile di compiti diversi. Una cosa che i cicli nidificati possono fare è cambiare il posizionamento in cui un oggetto viene generato per creare una torre come quella in questo video. Ci sono tre cicli diversi, uno ciascuno per controllare dove lungo la larghezza, lunghezza e altezza della torre il cubo viene generato.

Codifica uno script per creare cubi

Per esercitarti con i cicli nidificati, creerai uno script che genera una torre di cubi. Per lo script della torre di cubi, prima codice una funzione che genera un singolo cubo. La torre sarà costruita richiamando ripetutamente questa funzione.

Configura lo script

Per lo script della torre di cubi, prima codice una funzione che genera un singolo cubo. La torre sarà costruita richiamando ripetutamente questa funzione.

Elimina lo script PartMaker o disabilitalo (nelle proprietà dello script, seleziona Disabilitato). Se non lo fai, ci saranno due script che generano pezzi allo stesso tempo nello stesso luogo.
Crea un nuovo script chiamato TowerBuilder. Aggiungi variabili per la dimensione della torre e la dimensione del cubo in cima.
```
local TOWER_SIZE = 4
local CUBE_SIZE = 2
```
Nota come le variabili sopra sono tutte scritte in maiuscolo. Queste vengono chiamate costanti, o variabili che non cambiano. Per distinguerle dalle variabili che verranno modificate all'interno dello script, digitate utilizzando maiuscole e trattini bassi.

Aggiungi una funzione locale chiamata makeCube() che crea un singolo cubo quadrato utilizzando CUBE_SIZE.


local TOWER_SIZE = 4
local CUBE_SIZE = 2

-- Crea i singoli cubi
local function makeCube()
  local cube = Instance.new("Part")
  cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
end

Imposta il colore del cubo su una variabile che verrà aggiornata nei cicli nidificati.


local function makeCube()
  local cube = Instance.new("Part")
  cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
  cube.Color = currentColor
end

Infine, parent il nuovo cubo allo spazio di lavoro affinché appaia.


local function makeCube()
    local cube = Instance.new("Part")
    cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
    cube.Color = currentColor
    cube.Parent = workspace
end

Nel codice Roblox, una volta creato un oggetto tramite uno script, è consigliabile farne il parent alla fine. È più veloce apportare modifiche a un'istanza prima che ci sia un oggetto fisico nel mondo 3D.

Genera in direzioni diverse

Per creare una torre, genera cubi in punti specifici impostando le proprietà X, Y, Z di ciascun nuovo cubo. X e Z sono uno accanto all'altro. Y è su e giù.

In makeCube(), aggiungi parametri per spawnX, spawnY e spawnZ. Questi numeri imposteranno la posizione di generazione di ciascun nuovo cubo.


-- Crea i singoli cubi
local function makeCube(spawnX, spawnY, spawnZ)
    local cube = Instance.new("Part")
    cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
    cube.Color = currentColor
    cube.Parent = workspace
end

All'interno della funzione, imposta la proprietà CFrame del cubo su un nuovo CFrame utilizzando i parametri spawnX, spawnY, spawnZ.


local function makeCube(spawnX, spawnY, spawnZ)
    local cube = Instance.new("Part")
    cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
    cube.Color = currentColor
    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)
    cube.Parent = workspace
end

In Roblox, CFrame è un tipo di dato utilizzato per memorizzare posizione e orientamento 3D. Viene utilizzato per posizionare gli oggetti in un mondo.

Genera con cicli nidificati

Lo script avrà un totale di tre cicli, uno ciascuno per la lunghezza, la larghezza e l'altezza della torre. Per completare un intero piano prima di muoversi verso l'alto, inizia impostando la coordinata Y nel primo ciclo esterno.

Sotto la funzione makeCube(), crea un ciclo for per impostare quanto in alto viene generato ciascun cubo.
- Variabile di controllo: heightIndex = 1
- Punto finale: TOWER_SIZE
- All'interno del ciclo, aggiungi: local spawnY = (heightIndex - 1) * CUBE_SIZE
```
-- Costruisce la torre
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end
```
Il calcolo per spawnY assicura che il primo cubo venga generato all'altezza del suolo e poi si muova per lo spazio di un singolo cubo ogni volta. Il livello del suolo è a 0, il che è il motivo per cui bisogna sottrarre 1 dall'heightIndex.

Con il primo ciclo per l'altezza completato, inizia il secondo. All'interno del primo ciclo for, aggiungi un nuovo ciclo for per dove posizionare il cubo lungo la lunghezza della torre.

Variabile di controllo: lengthIndex = 1
Punto finale: TOWER_SIZE
All'interno di quel ciclo aggiungi: local spawnX = lengthIndex * CUBE_SIZE


for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE

    for lengthIndex = 1, TOWER_SIZE do
        local spawnX = lengthIndex * CUBE_SIZE
    end
end

Quando lavori con cicli nidificati, è importante assicurarsi che il codice sia ben indentato. Questo aiuta a rendere il tuo codice leggibile e organizzato.

All'interno del secondo ciclo, aggiungi un terzo ciclo for per la larghezza della torre. In questo ciclo finale, chiama makeCube() e passa i parametri X, Y, Z.

Variabile di controllo: widthIndex = 1
Punto finale: TOWER_SIZE
All'interno del ciclo aggiungi:
- local spawnZ = widthIndex * CUBE_SIZE
- makeCube(spawnX, spawnY, spawnZ)
- Un tempo di attesa di 0.25 in modo da poter osservare la costruzione della torre.


-- Costruisce la torre
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE

    for lengthIndex = 1, TOWER_SIZE do
        local spawnX = lengthIndex * CUBE_SIZE

        for widthIndex = 1, TOWER_SIZE do
            local spawnZ = widthIndex * CUBE_SIZE
            makeCube(spawnX, spawnY, spawnZ)
            task.wait(0.25)
        end
    end
end

Per far sì che ciascun piano sia di un colore casuale, modifica currentColor in numeri RGB casuali nello stesso ciclo in cui crei un nuovo piano.


for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
    currentColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))
    for lengthIndex = 1, TOWER_SIZE do
        local spawnX = lengthIndex * CUBE_SIZE
        for widthIndex = 1, TOWER_SIZE do
            local spawnZ = widthIndex * CUBE_SIZE
            makeCube(spawnX, spawnY, spawnZ)
            task.wait(0.25)
        end
    end
end

Esegui il progetto e attendi di vedere che è stata creata un'intera torre senza errori nella finestra di output.

Sfide opzionali

Di seguito ci sono diverse sfide autogestite che utilizzano i cicli nidificati in modi diversi. Prova a codificare da solo prima di guardare la soluzione.

Fascia di parti

Mentre la torre viene costruita, fai sfumare le parti in trasparenza da sinistra a destra.

La soluzione di codice è qui sotto.


local TOWER_SIZE = 6
local CUBE_SIZE = 2

-- Crea i singoli cubi
local function makeCube(spawnX, spawnY, spawnZ)
    local cube = Instance.new("Part")
    cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
    cube.Color = currentColor
    cube.Transparency = cubeTransparency -- Imposta la trasparenza
    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)
    cube.Parent = workspace
end

-- Costruisce la torre
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
    currentColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))

    for lengthIndex = 1, TOWER_SIZE do
        local spawnX = lengthIndex * CUBE_SIZE
	cubeTransparency = (lengthIndex - 1) * 0.10 -- Aggiornamenti ogni ciclo iniziando da 0

        for widthIndex = 1, TOWER_SIZE do
            local spawnZ = widthIndex * CUBE_SIZE
            makeCube(spawnX, spawnY, spawnZ)
            task.wait(0.05)
        end
    end
end

Fai piovere oggetti

Invece delle parti, prova a generare un oggetto reale. L'esempio qui utilizzava cupcake.

Da solo, prova a:

Creare un oggetto da parti di base. Assicurati di saldare tutte le parti insieme in modo che l'oggetto non si rompa.
Posizionare l'oggetto in ServerStorage.
Modificare il PartMaker trovato nell' Esempio di ciclo nidificato per utilizzare il tuo oggetto invece delle parti.

Un campione è mostrato qui.

Una soluzione di codice che utilizza cupcake è inclusa.


local numberOfBatches = 30
local cupcakesPerBatch = 6

local cupcakesBaked = 0

-- Crea un singolo cupcake
local function makeCupcake()
    local ServerStorage = game:GetService("ServerStorage")
    local cupcake = ServerStorage.Cupcake:Clone()
    local cup = cupcake.Cup
    local frosting = cupcake.Frosting
    cupcake:SetPrimaryPartCFrame(CFrame.new(0, 20, 0) * CFrame.Angles(0, 0, -90))
    frosting.Color = frostingColor
    cup.Color = cupColor
    cupcake.Parent = workspace
end


-- Ciclo esterno
for cupcakeBatch = 1, numberOfBatches do
    print("Ciclo esterno superiore: lotto di cupcake " .. cupcakeBatch)
    frostingColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))
    cupColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))

    -- Ciclo interno
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("Ciclo interno: cupcake " .. cupcakeNumber)
        -- Tieni traccia dei cupcake cotti
        cupcakesBaked += 1
        task.wait(0.5)
    end

    print("Ciclo esterno inferiore: " .. cupcakesBaked .. " cupcake cotti finora.")
end

Sintesi

Per svolgere compiti più complessi, ai programmatori può essere utile combinare più cicli, e persino diversi tipi di cicli. Tutti i cicli possono essere nidificati, il che significa che un ciclo è all'interno di un altro. I cicli nidificati seguono la stessa logica di qualsiasi altro ciclo. Inizia nel primo ciclo esterno, esegue compiti attraverso i cicli interni e quindi torna al primo ciclo se necessario.