Laços aninhados

*Este conteúdo é traduzido por IA (Beta) e pode conter erros. Para ver a página em inglês, clique aqui.

Os loops aninhados permitem que você repita tarefas em lotes. Por exemplo, assar três lotes de seis cupcakes ou atribuir armas a jogadores em duas equipes.

Como loops aninhados executar

Quando os loops são aninhados, os scripts vão linha por linha até chegar ao próximo loop.O ciclo interno será executado até que a condição seja atendida antes de retornar ao ciclo externo.

Lógica de ciclo aninhado

O seguinte diagrama mostra os passos que um loop toma.

  • Ciclo externo: o código é executado linha por linha até chegar ao ciclo interno.:
  • Ciclo externo: o código é executado linha por linha até chegar ao ciclo interno.:
  • Laço externo: o código é executado linha por linha até chegar ao laço interno.

Exemplo de loop aninhado

Laços aninhados podem parecer um pouco abstratos, então um exemplo visual pode ajudar.Para este exercício, copie e cole um script de amostra e execute-o no Studio.Este script criará torres de peças.O ciclo externo controlará quantas peças fazer, enquanto o ciclo interno criará o lote real.

  1. Crie um novo script em Serviço de Script de Servidor chamado PartMaker. Copie o código abaixo.

    local numberOfBatches = 7

    local partsPerBatch = 5

    local partsMade = 0

    

    -- Cria um único 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

    

    -- Laço externo

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

    

      -- Laço 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. Assista ao script gerar um lote diferente de peças coloridas.Depois de passar por um lote, ele vai pausar por 2 segundos.A declaração de impressão no loop externo será executada apenas uma vez por ciclo interno concluído.

Nesteado para torre de loop

Cada loop tem seu próprio conjunto de código, então pode ser responsável por diferentes tarefas.Uma coisa que loops aninhados podem fazer é alterar o posicionamento de onde um objeto é gerado para criar uma torre como a neste vídeo.Existem três loops diferentes, um para cada controle de onde ao longo da largura, comprimento e altura da torre o cubo é gerado.

Codifique um script de criador de cubos

Para praticar loops aninhados, você fará um script que cria uma torre de cubos.Para o script da torre cúbica, primeiro código uma função que gera um único cubo.A torre será construída chamando repetidamente essa função.

Configure o script

Para o script da torre cúbica, primeiro código uma função que gera um único cubo. A torre será construída ao chamar repetidamente essa função.

  1. Exclua o script do PartMaker ou desative-o (nas propriedades do script, verifique Desativado).Se você não fizer, haverá dois scripts fazendo peças ao mesmo tempo no mesmo local.

  2. Crie um novo script chamado TowerBuilder. Adicione variáveis para o tamanho da torre e do cubo no topo.

    local TOWER_SIZE = 4

    local CUBE_SIZE = 2

  3. Adicione uma função local chamada makeCube() que cria um cubo quadrado único usando CUBE_SIZE.

    local TOWER_SIZE = 4

    local CUBE_SIZE = 2

    

    -- Cria cubos individuais

    local function makeCube()

      local cube = Instance.new("Part")

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

    end

  4. Defina a cor do cubo para uma variável que será atualizada nos loops aninhados.

    local function makeCube()

      local cube = Instance.new("Part")

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

      cube.Color = currentColor

    end

  5. Por fim, pai o novo cubo para o espaço de trabalho para que ele apareça.

    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 em diferentes direções

Para criar uma torre, gere cubos em pontos específicos ao definir as propriedades X, Y, Z de cada novo cubo. X e Z estão lado a lado. Y está para cima e para baixo.

  1. Em makeCube() , adicione parâmetros para spawnX , spawnY e spawnZ . Esses números definirão a localização de spawn de cada novo cubo.

    -- Cria cubos individuais

    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. Dentro da função, defina a propriedade CFrame do cubo para um novo CFrame usando os parâmetros spawnX, spawnY e 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 com loops aninhados

O script terá três loops no total, um para cada comprimento, largura e altura da torre.Para completar um andar inteiro antes de se mover para cima, comece por definir a coordenada Y no primeiro ciclo externo.

  1. Sob a função makeCube() Criar um ciclo for para definir como alto cada cubo é gerado.

    • Variável de controle : heightIndex = 1
    • Ponto final : TOWER_SIZE
    • Dentro do loop, adicionar: spawnY local = (indexe de altura - 1) * CUBE_SIZE
    -- Construir torre

    for heightIndex = 1, TOWER_SIZE do

        local spawnY = (heightIndex - 1) * CUBE_SIZE

    end

  2. Com o primeiro ciclo para altura terminado, comece no segundo.Dentro do primeiro para ciclo, adicione um novo para ciclo para onde colocar o cubo ao longo da torre.

    • Variável de controle : lengthIndex = 1
    • Ponto final : TOWER_SIZE
    • Dentro desse loop adicionar: spawnX local = 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

  3. Dentro do segundo loop , adicione um terceiro loop para o ciclo da torre largura .Neste ciclo final, chame makeCube() e passe os parâmetros X, Y, Z.

    • Variável de controle : widthIndex = 1
    • Ponto final : TOWER_SIZE
    • Dentro do loop adicionar:
      • local spawnZ = widthIndex * CUBE_SIZE
      • makeCube(spawnX, spawnY, spawnZ)
      • Um tempo de espera de 0,25 para que você possa assistir à construção da torre.
    -- Construir 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. Para que cada andar seja de uma cor aleatória, altere currentColor para números aleatórios RGB no mesmo loop em que você cria um novo andar.

    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. Execute o projeto e aguarde para ver que uma torre completa foi criada sem erros na janela de Saída.

Desafios facultativos

Abaixo estão diferentes desafios autodirigidos que usam loops aninhados de diferentes maneiras. Tente e coda por conta própria antes de olhar para a solução.

Desaparecer peças

À medida que a torre é construída, tenha as peças desaparecerem em transparência da esquerda para a direita.

A solução de código está abaixo.

local TOWER_SIZE = 6

local CUBE_SIZE = 2



-- Cria cubos individuais

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 -- Define transparência

    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)

    cube.Parent = workspace

end



-- Construir 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 --Atualiza cada loop começando em 0



        for widthIndex = 1, TOWER_SIZE do

            local spawnZ = widthIndex * CUBE_SIZE

            makeCube(spawnX, spawnY, spawnZ)

            task.wait(0.05)

        end

    end

end

Faça chover objetos

Em vez de peças, tente gerar um Objetoreal. O exemplo aqui usou cupcakes.

Por conta possuir, veja se você pode:

  • Crie um objeto a partir de peças base. Certifique-se de soldar todas as peças juntas para que o objeto não se divida.
  • Coloque o objeto no Armazenamento do Servidor
  • Modifique o PartMaker encontrado no Exemplo de Ciclo Aninhado para usar seu objeto em vez de peças.

Uma amostra é mostrada aqui.

Uma solução de código usando cupcakes é incluída.

local numberOfBatches = 30

local cupcakesPerBatch = 6



local cupcakesBaked = 0



--Faz um único 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





-- Laço externo

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



    -- Laço interno

    for cupcakeNumber = 1, cupcakesPerBatch do

        makeCupcake()

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

        -- Rastrear muffins assados

        cupcakesBaked += 1

        task.wait(0.5)

    end



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

end

Sumário

Para realizar tarefas mais complexas, os programadores acharão útil combinar múltiplos loops e até mesmo diferentes tipos de loops.Todos os loops podem ser aninhados, o que significa que um loop está dentro de outro.Laços aninhados seguem a mesma lógica de qualquer outro loop.Começa no primeiro, último ciclo, executa tarefas através de ciclos internos e, em seguida, cicla de volta ao primeiro ciclo, se Aplicável.

Anterior
Próximo