Loop annidati

*Questo contenuto è tradotto usando AI (Beta) e potrebbe contenere errori. Per visualizzare questa pagina in inglese, clicca qui.

I cicli di nidificazione ti consentono di ripetere le attività in batch. Ad esempio, cuocere tre batch di sei cupcake o assegnare armi ai giocatori di due squadre.

Come Eseguireeseguiti i cicli nidati

Quando i loop sono annidati, gli script vanno linea per linea fino a raggiungere il prossimo ciclo.Il ciclo interno eseguirà fino a quando non sarà soddisfatta la sua condizione prima di tornare al ciclo esterno.

Logica del ciclo ancorato

Il seguente diagramma mostra i passi che un ciclo compie.

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

Esempio di ciclo ancorato

I loop annidati possono sembrare un po' astratti, 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 ciclo esterno controllerà quante parti realizzare, mentre il ciclo interno creerà l'effettiva batch.

  1. 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("Top outer loop: part batch " .. partBatch)

      currentColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))

    

      -- Loop 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

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

Nested per torre a ciclo anello

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

Codifica uno script creatore di cubi

Per praticare i loop annidati, creerai uno script che crea una torre di cubi.Per lo script della torre cubica, prima codifica una funzione che genera un singolo cubo.La torre verrà costruita ripetendo più volte questa funzione.

Configurare lo script

Per lo script della torre cubica, prima codifica una funzione che genera un singolo cubo. La torre verrà costruita ripetendo più volte questa funzione.

  1. Elimina lo script PartMaker o disabilitalo (nelle proprietà dello script, controlla Disabilitato).Se non lo fai, ci saranno due script che faranno parti allo stesso tempo nello stesso Posto.

  2. Crea un nuovo script chiamato TowerBuilder. Aggiungi le variabili per la dimensione della torre e la dimensione del cubo in cima.

    local TOWER_SIZE = 4

    local CUBE_SIZE = 2

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

    local TOWER_SIZE = 4

    local CUBE_SIZE = 2

    

    -- Crea cubi individuali

    local function makeCube()

      local cube = Instance.new("Part")

      cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)

    end

  4. Imposta il colore del cubo su una variabile che verrà aggiornata nei loop nidati.

    local function makeCube()

      local cube = Instance.new("Part")

      cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)

      cube.Color = currentColor

    end

  5. Infine, padre il nuovo cubo allo spazio di lavoro 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

Spawn in direzioni diverse

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

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

    -- Crea cubi individuali

    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

  2. All'interno della funzione, imposta la proprietà CFrame del cubo a 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

Spawn con loop annidati

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

  1. Sotto la funzione makeCube() , crea un ciclo while per impostare come alto ogni cubo viene generato.

    • Variabile di controllo : heightIndex = 1
    • Punto di fine : TOWER_SIZE
    • All'interno del ciclo, aggiungere or Inserire: local spawnY = (heightIndex - 1) * CUBE_SIZE
    -- Costruisce la torre

    for heightIndex = 1, TOWER_SIZE do

        local spawnY = (heightIndex - 1) * CUBE_SIZE

    end

  2. Con il primo ciclo per l'altezza terminato, inizia sul secondo.All'interno del primo ciclo while, aggiungi un nuovo ciclo while per il luogo in cui posizionare il cubo lungo la lunghezza della torre.

    • Variabile di controllo : lengthIndex = 1
    • Punto di fine : TOWER_SIZE
    • All'interno di quel ciclo aggiungere or Inserire: spawnX locale = lunghezzaIndice * 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

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

    • Variabile di controllo : widthIndex = 1
    • Punto di fine : TOWER_SIZE
    • All'interno del ciclo aggiungere or Inserire:
      • local spawnZ = widthIndex * CUBE_SIZE
      • makeCube(spawnX, spawnY, spawnZ)
      • Un tempo di attesa di 0,25 così puoi 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

  4. Per far sì che ogni piano sia di un colore casuale, cambia currentColor in numeri casuali RGB nella stessa 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

  5. Esegui il progetto e attendi di vedere che una torre completa è stata creata senza errori nella finestra di output.

Sfide opzionali

Di seguito sono riportate diverse sfide autodirigate che utilizzano cicli nidati in modi diversi. Prova e programma da solo prima di esaminare la soluzione.

Sbiadire le parti

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

La soluzione del codice è qui sotto.

local TOWER_SIZE = 6

local CUBE_SIZE = 2



-- Crea cubi individuali

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 ciclo che inizia a 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 di parti, prova a generare un oggetto reale. L'esempio qui utilizzato i cupcake.

Da Proprio, vedi se puoi:

  • Crea un oggetto da parti di base. Assicurati di saldare tutte le parti insieme in modo che l'oggetto non si disintegri.
  • Posiziona l'oggetto in ServerStorage
  • Modifica il PartMaker trovato nel Esempio di ciclo ancorato per utilizzare il tuo oggetto invece delle parti.

Un campione viene mostrato qui.

Una soluzione di codice utilizzando i 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))



    -- Loop interno

    for cupcakeNumber = 1, cupcakesPerBatch do

        makeCupcake()

        print("Inner loop: cupcake " .. cupcakeNumber)

        -- Muffin di traccia cotti

        cupcakesBaked += 1

        task.wait(0.5)

    end



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

end

Sommariamente

Per svolgere compiti più complessi, i programmatori troveranno utile combinare più loop e persino diversi tipi di loop.Tutti i loop possono essere annidati, cioè che uno loop è all'interno di un altro.I loop annidati seguono la stessa logica di qualsiasi altro ciclo.Inizia nel primo, ultimo ciclo, esegue le attività attraverso i cicli interni e poi ritorna al primo ciclo se Applicabile.

Precedente
Prossimo