Ciclos Ninados | Documentação - Central de Criadores Roblox

Nesting loops permite repetir tarefas em lotes. Por exemplo, fazer três lotes de seis cupcakes ou atribuir armas a jogadores em duas equipes.

Como Loops Nestados são executados

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

Lógica de Loop Nestado

O seguinte diagrama mostra os passos que um ciclo leva.

Loop externo: código é executado em linha até que chegue ao loop externo.
Loop externo: código é executado em linha até que chegue ao loop externo.
Loop externo: código é executado em linha até que chegue ao loop externo.

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

Crie um novo script em ServerScriptService chamado PartMaker. Copie o código abaixo.


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

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

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

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

Assista enquanto o script gera uma diferente batuta de peças coloridas. Depois de passar por um lote, ele será interrompido por 2 segundos. A declaração de impressão na retorno de loop só será executada uma vez por cada loop concluído.

Nestado para Torre de Loop

Cada loop tem seu próprio conjunto de código, para que possa ser responsável por diferentes tarefas. Uma coisa que os loops aninhados podem fazer é alterar o local de onde um objeto é gerado para criar uma torre como a nesta vídeo. Existem três diferentes loops, um para cada controlar onde ao longo da largura, comprimento e altura da torre o cube spawns.

Codificando um Cube Maker Script

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

Configurando o Script

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

Excluir o script PartMaker ou desativá-lo (nas propriedades do script, verificar Desativado). Se você não, haverá dois scripts fazendo peças ao mesmo tempo no mesmo local.
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
```
Notice como as variáveis acima são todas capitalizadas. Estas são chamadas de constantes , ou variáveis que não mudam. Para definí-las em relação às variáveis que serão alteradas dentro do script, digite-as usando minúsculas e traços.

Adicione uma função local chamada makeCube() que cria um único cubo de tamanho 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

Defina a cor do cubo para uma variável que será atualizada em ciclos aninhados.


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

Por último, parent 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

No código Roblox, uma vez que um objeto é criado por script, é recomendado que você o pais no terminar/parar/sair. É mais rápido fazer alterações em uma instância antes que haja um objeto físico no mundo do jogo.

Spawning em Direções Diferentes

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

In makeCube(), adicionar parâmetros para spawnX, spawnY e 1> spawnZ1>. 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

Dentro da função, set the cube's CFrame property to a new CFrame usando os parâmetros 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

No Roblox, CFrame é um tipo de dado usado para armazenar posição e orientação 3D. É usado para colocar objetos em um mundo.

Gerando com Loops Ninados

O script terá três loops totais, um para a comprimento, largura e altura da torre. Para completar um andar inteiro antes de se mover para cima, comece com a configuração da coordenada Y no primeiro, último loop.

Sob a função makeCube(), crie um para loop para definir como altos cada cube spawns.
- Variável de controle : heightIndex = 1
- Pontos de fim : TOWER_SIZE
- Dentro do loop, adicionar: local spawnY = (alturaIndex - 1) * CUBE_SIZE
```
-- Construi torre
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end
```
A calculadora para spawnY certifica-se de que o primeiro cubo é gerado em altura do chão e, em seguida, é movido sobre o espaço de um único cubo a cada vez. O nível do chão é 0, o que é por que 1 precisa ser subtraido do heightIndex.

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

Variável de controle : lengthIndex = 1
Pontos de fim : TOWER_SIZE
Dentro desse loop adicionar: 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

Ao trabalhar com loops aninhados, é importante garantir que o código esteja bem emparelhado. Isso ajuda a tornar seu código lível e organizado.

Dentro do segundo loop, adicione um terceiro para loop para a torre largura. Neste loop final, chame 2> makeCube()2> e passe pelos parâmetros X, Y e Z.

Variável de controle : widthIndex = 1
Pontos de fim : 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.


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

Para que cada andar seja uma cor aleatória, altere currentColor para aleatório RGB números na mesma 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

Execute o projeto e aguarde para ver que uma torre completa foi criada sem nenhum erro na Janela de Saída.

Desafios Opcionais

Abaixo estão diferentes desafios de autogerenciamento que usam loops em diferentes maneiras. Tente e code em seu próprio antes de olhar para a solução.

Peças Fade Away

À medida que a torre é construída, faz com que as peças desapareçam 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 a transparência
    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)
    cube.Parent = workspace
end

-- Construi 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ções a 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

Objetos de Chuva

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

Por conta possuir, ver se você pode:

Crie um objeto a partir de peças de base. Certifique-se de soldar todas as peças juntas para que o objeto não seja quebrado.
Coloque o objeto no ServerStorage
Modifique o PartMaker encontrado no Exemplo de Loop Nestado para usar seu objeto em vez de peças.

Um exemplo está mostrado aqui.

Uma solução de código usando cupcakes está 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


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

    -- Loop interno
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("Inner loop: cupcake " .. cupcakeNumber)
        -- Rastros de muffin assados
        cupcakesBaked += 1
        task.wait(0.5)
    end

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

Visão Geral

Para realizar tarefas mais complexas, os desenvolvedores encontrarão útil combinar vários loops, e até mesmo diferentes tipos de loops. Todos os loops podem ser aninhados, o que significa que um loop está dentro de outro. Os loops aninhados seguem a mesma lógica que qualquer outro loop. Ele começa no primeiro, último loop, executa tarefas através de loops internos e, em seguida, cicla de volta ao primeiro loop se Aplicável.