Loops aninhados | Documentação - Central de Criadores Roblox

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

Como funcionam os loops aninhados

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

Lógica de Loop Aninhada

O diagrama a seguir mostra os passos de um loop.

Círculo exterior: el código se ejecuta línea por línea hasta que llegue al bucle interior.
Círculo exterior: el código se ejecuta línea por línea hasta que llegue al bucle interior.
Círculo exterior: el código se ejecuta línea por línea hasta que llegue al bucle interior.

Os loops 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 corra-o no Studio. Este script criará torres de peças. O loop exterior controlará quantas partes fazer, enquanto o loop interno criará o lote real.

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

-- Laço exterior
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

Veja como o script gera um lote diferente de peças coloridas. Depois de passar por um lote, ele ficará em pausa por 2 segundos. A instrução de impressão no loop externo será rodada apenas uma vez por loop interno concluído.

Aninhado para Loop Tower

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

Codificando 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 de cubos, primeiro codifique uma função que gera um único cubo. A torre será construída chamando essa função repetidamente.

Configurando o Script

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

Apague o script PartMaker ou desative-o (nas propriedades do script, marque Desativado). Se você não fizer isso, haverá dois scripts fazendo partes ao mesmo tempo no mesmo local.
Crie um novo script chamado TowerBuilder. Adicione variáveis para o tamanho da torre e o tamanho do cubo no topo.
```
local TOWER_SIZE = 4
local CUBE_SIZE = 2
```
Observe como as variáveis acima são todas capitalizadas. Estas são chamadas de constantes , ou variáveis que não mudam. Para defini-las à parte das variáveis que serão alteradas no script, digite-as usando maiús e sublinhado.

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

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

Finalmente, pai o novo cubo para a área 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 do Roblox, uma vez que um objeto é criado pelo script, é recomendado criá-lo 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.

Aparecendo em Direções Diferentes

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

Em makeCube() , adicione parâmetros para spawnX , spawnY , e spawnZ . Esses números definirão o local 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, defina a propriedade CFrame do cubo para um novo 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

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

Aparecendo com Loops Aninhados

O script terá três loops no total, um para o comprimento, largura e altura da torre. Para completar um andar inteiro antes de avançar para cima, comece configurando a coordenada Y no primeiro loop mais externo.

Sob a função makeCube(), crie um loop para definir como alto cada cubo aparece.
- Variável de controle : heightIndex = 1
- Ponto final : TOWER_SIZE
- Dentro do loop, adicionar: local spawnY = (heightIndex - 1) * CUBE_SIZE
```
-- Construi torre
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end
```
A contagem para spawnY garante que o primeiro cubo apareça na altura do solo e depois se mova pelo espaço de um único cubo a cada vez. O nível do solo está em 0, e é por isso que 1 precisa ser subtraído do heightIndex .

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

Variável de controle : lengthIndex = 1
Ponto final : 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 inserido. Isso ajuda a tornar seu código legível e organizado.

Dentro do segundo loop, adicione um terceiro para o loop para a torre largura . Neste loop final, chame makeCube() e passe nos 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 a torre ser construída.


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

Corra o projeto e espere para ver que uma torre completa foi criada sem erros na Janela de Saída.

Desafios Opcionais

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

Desvanecer Peças

À medida que a torre é construída, as partes desaparecem em transparência da esquerda para a direita.

A solução do 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 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.

possuir, veja se você pode:

Crie um objeto a partir de peças básicas. Certifique-se de soldar todas as peças juntas para que o objeto não caia em pedaços.
Coloque o objeto no ServerStorage
Modifique o PartMaker encontrado no Exemplo de Loop Aninhado para usar seu objeto em vez de peças.

Uma amostra é mostrada 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


-- Laço exterior
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)
        -- Muffins de trilha assados
        cupcakesBaked += 1
        task.wait(0.5)
    end

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

Resumo

Para realizar tarefas mais complexas, os codificadores acharã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. Loops aninhados seguem a mesma lógica que qualquer outro loop. Começa no primeiro loop, mais externo, realiza tarefas através de loops internos e, em seguida, retorna ao primeiro loop, se Aplicável.