Bucles anidados | Documentación del Centro de creación de Roblox

Anidar bucles te permite repetir tareas en lotes. Por ejemplo, hornear tres lotes de seis magdalenas o asignar armas a jugadores en dos equipos.

Cómo se ejecutan los bucles anidados

Cuando los bucles están anidados, los scripts van línea por línea hasta que llegan al siguiente bucle. El bucle interno se ejecutará hasta que se cumpla su condición antes de volver al bucle externo.

Lógica del bucle anidado

El siguiente diagrama muestra los pasos que toma un bucle.

Bucles externo: el código se ejecuta línea por línea hasta que llega al bucle interno.
Bucles externo: el código se ejecuta línea por línea hasta que llega al bucle interno.
Bucles externo: el código se ejecuta línea por línea hasta que llega al bucle interno.

Los bucles anidados pueden parecer algo abstractos, así que un ejemplo visual puede ayudar. Para este ejercicio, copia y pega un script de muestra y ejecútalo en Studio. Este script creará torres de partes. El bucle externo controlará cuántas partes hacer, mientras que el bucle interno creará el lote real.

Crea un nuevo script en ServerScriptService llamado PartMaker. Copia el código a continuación.


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

-- Bucle externo
for partBatch = 1, numberOfBatches do
  print("Bucle externo superior: lote de partes " .. partBatch)
  currentColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))

  -- Bucle interno
  for partNumber = 1, partsPerBatch do
    createPart()
    print("Bucle interno: parte " .. partNumber)
    partsMade += 1
    task.wait(0.5)
  end

  print("Bucle externo inferior: " .. partsMade .. " partes hechas hasta ahora.")

  task.wait(2)
end

Observa cómo el script genera un lote diferente de partes de colores. Después de completar un lote, se detendrá durante 2 segundos. La declaración de impresión en el bucle externo se ejecutará solo una vez por cada bucle interno completado.

Torre de bucles for anidados

Cada bucle tiene su propio conjunto de código, por lo que puede ser responsable de diferentes tareas. Una cosa que los bucles anidados pueden hacer es cambiar la colocación de dónde aparece un objeto para crear una torre como la de este video. Hay tres bucles diferentes, uno para controlar dónde a lo largo del ancho, longitud y altura de la torre el cubo aparece.

Código de un script generador de cubos

Para practicar los bucles anidados, crearás un script que genera una torre de cubos. Para el script de la torre de cubos, primero codifica una función que genera un solo cubo. La torre se construirá llamando repetidamente a esta función.

Configura el script

Para el script de la torre de cubos, primero codifica una función que genera un solo cubo. La torre se construirá llamando repetidamente a esta función.

Elimina el script PartMaker o desactívalo (en las propiedades del script, marca Deshabilitado). Si no lo haces, habrá dos scripts creando partes al mismo tiempo en el mismo lugar.
Crea un nuevo script llamado TowerBuilder. Agrega variables para el tamaño de la torre y el tamaño del cubo en la parte superior.
```
local TOWER_SIZE = 4
local CUBE_SIZE = 2
```
Nota cómo las variables anteriores están capitalizadas. Estas se llaman constantes, o variables que no cambian. Para diferenciarlas de las variables que se cambiarán dentro del script, escríbelas usando mayúsculas y guiones bajos.

Agrega una función local llamada makeCube() que crea un solo cubo cuadrado usando CUBE_SIZE.


local TOWER_SIZE = 4
local CUBE_SIZE = 2

-- Crea cubos individuales
local function makeCube()
  local cube = Instance.new("Part")
  cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
end

Establece el color del cubo en una variable que se actualizará en los bucles anidados.


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

Por último, parenta el nuevo cubo al espacio de trabajo para que aparezca.


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

En el código de Roblox, una vez que un objeto es creado por el script, se recomienda parentarlo al final. Es más rápido hacer cambios en una instancia antes de que haya un objeto físico en el mundo 3D.

Generar en diferentes direcciones

Para crear una torre, genera cubos en puntos específicos estableciendo las propiedades X, Y, Z de cada nuevo cubo. X y Z son lado a lado. Y es arriba y abajo.

En makeCube(), agrega parámetros para spawnX, spawnY, y spawnZ. Estos números establecerán la ubicación de generación de cada nuevo cubo.


-- Crea cubos individuales
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 de la función, establece la propiedad CFrame del cubo en un nuevo CFrame usando los 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

En Roblox, CFrame es un tipo de dato utilizado para almacenar posición y orientación 3D. Se utiliza para colocar objetos en un mundo.

Generar con bucles anidados

El script tendrá un total de tres bucles, uno para la longitud, otro para el ancho y uno para la altura de la torre. Para completar un piso completo antes de mover hacia arriba, empieza estableciendo la coordenada Y en el primer bucle más externo.

Bajo la función makeCube(), crea un bucle for para establecer cuán alto se genera cada cubo.
- Variable de control: heightIndex = 1
- Punto final: TOWER_SIZE
- Dentro del bucle, agrega: local spawnY = (heightIndex - 1) * CUBE_SIZE
```
-- Construye la torre
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end
```
El cálculo para spawnY asegura que el primer cubo se genere a nivel del suelo y luego se mueva sobre el espacio de un solo cubo cada vez. El nivel del suelo está en 0, por lo que se necesita restar 1 del heightIndex.

Con el primer bucle para la altura terminado, comienza con el segundo. Dentro del primer bucle for, agrega un nuevo bucle for para dónde colocar el cubo a lo largo de la longitud de la torre.

Variable de control: lengthIndex = 1
Punto final: TOWER_SIZE
Dentro de ese bucle agrega: 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

Al trabajar con bucles anidados, es importante asegurarse de que el código esté bien indentado. Esto ayuda a que tu código sea legible y organizado.

Dentro del segundo bucle, agrega un tercer bucle for para el ancho de la torre. En este bucle final, llama a makeCube() y pasa los parámetros X, Y, Z.

Variable de control: widthIndex = 1
Punto final: TOWER_SIZE
Dentro del bucle agrega:
- local spawnZ = widthIndex * CUBE_SIZE
- makeCube(spawnX, spawnY, spawnZ)
- Un tiempo de espera de 0.25 para que puedas observar la construcción de la torre.


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

Para que cada piso tenga un color aleatorio, cambia currentColor a números RGB aleatorios en el mismo bucle en el que creas un nuevo piso.


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

Ejecuta el proyecto y espera para ver que se ha creado una torre completa sin errores en la ventana de salida.

Retos opcionales

A continuación se presentan diferentes desafíos autodirigidos que utilizan bucles anidados de diferentes maneras. Intenta codificar por tu cuenta antes de ver la solución.

Desvanecer partes

A medida que se construye la torre, haz que las partes desaparezcan en transparencia de izquierda a derecha.

La solución de código se presenta a continuación.


local TOWER_SIZE = 6
local CUBE_SIZE = 2

-- Crea cubos individuales
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 -- Establece la transparencia
    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)
    cube.Parent = workspace
end

-- Construye 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 -- Se actualiza cada bucle comenzando en 0

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

Lluvia de objetos

En lugar de partes, intenta generar un objeto real. El ejemplo aquí utilizó magdalenas.

Por tu cuenta, ve si puedes:

Crear un objeto a partir de partes base. Asegúrate de soldar todas las partes juntas para que el objeto no se descomponga.
Coloca el objeto en ServerStorage.
Modifica el PartMaker encontrado en el Ejemplo de Bucle Anidado para usar tu objeto en lugar de partes.

Aquí se muestra un ejemplo.

Se incluye una solución de código utilizando magdalenas.


local numberOfBatches = 30
local cupcakesPerBatch = 6

local cupcakesBaked = 0

-- Crea una sola magdalena
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


-- Bucle externo
for cupcakeBatch = 1, numberOfBatches do
    print("Bucle externo superior: lote de magdalenas " .. 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))

    -- Bucle interno
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("Bucle interno: magdalena " .. cupcakeNumber)
        -- Rastrear magdalenas horneadas
        cupcakesBaked += 1
        task.wait(0.5)
    end

    print("Bucle externo inferior: " .. cupcakesBaked .. " magdalenas horneadas hasta ahora.")
end

Resumen

Para lograr tareas más complejas, los programadores encontrarán útil combinar múltiples bucles, e incluso diferentes tipos de bucles. Todos los bucles pueden ser anidados, lo que significa que un bucle está dentro de otro. Los bucles anidados siguen la misma lógica que cualquier otro bucle. Comienza en el primer bucle más externo, ejecuta tareas a través de bucles internos y luego vuelve al primer bucle si es aplicable.