Cicli annidati | Documentazione - Roblox Hub Creatori

I loop di nesting ti consentono di ripetere le attività in serie. Ad esempio, la cottura di tre lotte di sei cupcake, o l'assegnazione di armi ai giocatori in due team.

Come vengono eseguiti i cicli annidati

Quando i loop sono annidati, gli script vanno di riga in riga fino a quando non raggiungono il prossimo loop. L'inner loop sarà eseguito fino a quando non sarà soddisfatta la condizione prima di tornare all'esterno loop.

Logica a doppio loop

Il seguente diagramma mostra i passi che un ciclo esegue.

Loop esterno: il codice viene eseguito linea per linea fino a quando non raggiunge il loop interno.
Loop esterno: il codice viene eseguito linea per linea fino a quando non raggiunge il loop interno.
Loop esterno: il codice viene eseguito linea per linea fino a quando non raggiunge il loop interno.

Esempio di loop annidato

I loop può sembrare in qualche modo astratto, quindi un esempio visivo può Aiuto. Per questo esercizio, copia e pasta uno script di esempio e eseguilo in Studio. Questo script creerà torri di parti. Il loop esterno controllerà quante parti per fare, mentre il loop interno creerà il lotto reale.

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


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

-- Crea un solo 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("Top outer loop: part batch " .. 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("Inner loop: part " .. partNumber)
    partsMade += 1
    task.wait(0.5)
  end

  print("Bottom outer loop: " .. partsMade .. " parts made so far.")

  task.wait(2)
end

Guarda mentre lo script genera un differente lote di parti colorate. Dopo aver completato un lote, verrà eseguito per 2 secondi. La dichiarazione di stampa nell'itero esterno sarà eseguita solo una volta per ciascun lote completato.

Nestato per la torre a loop

Ogni loop ha il proprio set di codice, so it can be responsible for different tasks. One thing nested循环可以做是改变塔像这个视频中的位置。有三个 different loops, 一个 each for controlling where along the width, length, and height of the tower the cube spawns。

Codice di un Creatore di Cube

Per praticare i loop annidati, creerai uno script che crea una torre di cubi. Per lo script della torre dei cubi, prima di codice una funzione che genera un solo cubo. La torre sarà costruita ripetutamente chiamando questa funzione.

Configurazione dello script

Per lo script della torre a cubo, prima di codice una funzione che genera un solo cubo. La torre sarà costruita ripetutamente chiamando questa funzione.

Elimina lo script PartMaker o disabilitalo (nelle proprietà dello script, controlla Disabilitato). Se non lo fai, ci saranno due script che fanno le parti allo stesso tempo nello stesso Posto.
Crea uno script nuovo chiamato TowerBuilder. Aggiungi variabili per la dimensione della torre e la dimensione del cubo nella parte superiore.
```
local TOWER_SIZE = 4
local CUBE_SIZE = 2
```
Nota come le variabili sopra sono tutte in maiuscolo. Questi sono chiamati costanti , o variabili che non cambiano. Per impostarli separatamente dalle variabili che verranno modificate all'interno dello script, digitali usando maiuscole e trattini.

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


local TOWER_SIZE = 4
local CUBE_SIZE = 2

-- Crea 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 in una variabile che verrà aggiornata nei loop annidati.


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

Infine, genitore il nuovo cubo allo workspace in modo che 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 che un oggetto viene creato dal script, è consigliato genere padre all'Terminare. È più veloce fare le modifiche a un'istanza prima che ci sia un oggetto fisico nel Mondodel gioco.

Generazione in direzioni diverse

Per creare una torre, genera i cubi in punti specifici impostando le proprietà X, Y, Z di ciascun nuovo cubo. X e Z sono lato a lato. Y è su e giù.

In makeCube() , aggiungi parametri per spawnX , spawnY e 1> spawnZ1> . Questi numeri imposteranno la posizione di spawn di ogni nuovo cubo.


-- Crea 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 in 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 dati usato per memorizzare la posizione e l'orientamento 3D. Viene usato per posizionare oggetti in un Mondo.

Generazione con Loop Nestati

Lo script avrà tre loop totali, uno per la lunghezza, la larghezza e l'altezza della torre. Per completare un intero piano prima di spostarti verso l'alto, inizia con la impostazione della Y coordinate nel primo, ultimo loop.

Sotto la funzione makeCube(), crea un for loop per impostare in che modo alti ogni cube spawn.
- Variabile di controllo : heightIndex = 1
- punto di fine : TOWER_SIZE
- All'interno del loop, aggiungere or Inserire: local spawnY = (alturaIndex - 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 a terra e poi si muova attraverso lo spazio di un solo cubo ogni volta. Il livello di terra è a 0, il che è il motivo per cui 1 deve essere sottratto dal heightIndex .

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

Controllo variabile : lunghezzaIndex = 1
punto di fine : TOWER_SIZE
Dentro quel loop aggiungere or Inserire: 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 si lavora con loop annidati, è importante assicurarsi che il codice sia ben indennato. Ciò aiuta a rendere il tuo codice leggibile e organizzato.

All'interno del secondo ciclo, aggiungi un terzo per il ciclo per la torre larghezza . In questo ciclo finale, chiama 1> makeCube()1> e passa nel parametro X, Y, Z.

Controllo variabile : widthIndex = 1
punto di fine : TOWER_SIZE
All'interno del loop aggiungere or Inserire:
- local spawnZ = widthIndex * CUBE_SIZE
- makeCube(spawnX, spawnY, spawnZ)
- Un tempo di attesa di 0,25 in modo da poter guardare la torre essere costruita.


-- 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 avere ogni piano un colore casuale, cambia currentColor in un numero casuale RGB nel medesimo loop 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 aspetta che una torre completa sia stata creata senza errori nella finestra di uscita.

Sfide opzionali

Di seguito sono diversi i problemi autoguidati che usano i loop in modo diverso. Prova a codificare da solo prima di guardare alla soluzione.

Parti sbiadite

Mentre la torre viene costruita, fate sbiadire le parti nella trasparenza da sinistra a destra.

La soluzione del codice è qui sotto.


local TOWER_SIZE = 6
local CUBE_SIZE = 2

-- Crea 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 --Aggiorna ogni loop a partire da 0

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

Oggetti a pioggia

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

Da Proprio, vedi se puoi:

Crea un oggetto dalle parti di base. Assicurati di saldare tutte le parti insieme in modo che l'oggetto non si rompa.
Posiziona l'oggetto in ServerStorage
Modifica il PartMaker trovato in the Nested Loop Example to use your oggetto instead of parts.

Un esempio è mostrato qui.

Una soluzione di codice utilizzando 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("Top outer loop: cupcake batch " .. 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("Inner loop: cupcake " .. cupcakeNumber)
        -- Muffin di traccia benedetti
        cupcakesBaked += 1
        task.wait(0.5)
    end

    print("Bottom outer loop: " .. cupcakesBaked .. " cupcakes baked so far.")
end

Panoramica

Per completare compiti più complessi, i codici troveranno utile combinare più loop e persino diversi tipi di loop. Tutti i loop possono essere annidati, il che significa che uno dei loop è all'interno di un altro. I loop annidati seguono la stessa logica di qualsiasi altro loop. Inizia nel primo, ultimo loop, esegue compiti attraverso gli loop interni e poi ritorna al primo loop se Applicabile.