Círculos 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 de dos equipos.

Cómo funcionan los bucles anidados

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

Lógica de bucle anidado

El siguiente diagrama muestra los pasos que toma un bucle.

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.

Los bucles anidados pueden parecer algo abstractos, por lo 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 exterior controlará cuántas partes hacer, mientras que el bucle interior 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

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

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

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

Mira como el script genera un lote diferente de piezas de color. Después de pasar por un lote, se detendrá durante 2 segundos. La sentencia de impresión en el bucle exterior se ejecutará solo una vez por bucle interno completado.

Anidado para la torre de bucle

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

Codificación de un script de creador de cubos

Para practicar bucles anidados, harás un script que crea 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 esta función.

Configurando 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 de PartMaker o desactívalo (en las propiedades del script, marca Desactivado). Si no lo haces, habrá dos scripts haciendo partes al mismo tiempo en el mismo lugar.
Crea un nuevo script llamado TowerBuilder. Añade 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
```
Observe cómo las variables anteriores están todas en mayúsculas. Estas se llaman constantes , o variables que no cambian. Para establecerlas aparte de las variables que se cambiarán dentro del script, escríbalas usando mayúsculas y guiones bajos.

Añade 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

Finalmente, padre 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 script, se recomienda crearlo al finalizar. Es más rápido hacer cambios en una instancia antes de que haya un objeto físico en el mundo del juego.

Apareciendo en diferentes direcciones

Para crear una torre, genera cubos en puntos específicos configurando las propiedades X, Y y Z de cada nuevo cubo. X y Z están lado a lado. Y está arriba y abajo.

En makeCube() , agregue parámetros para spawnX , spawnY , y spawnZ . Estos números establecerán la lugar de regeneraciónde 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 datos utilizado para almacenar la posición y orientación 3D. Se utiliza para colocar objetos en un mundo.

Apareciendo con bucles anidados

El guión tendrá tres bucles en total, uno cada uno para la longitud, anchura y altura de la torre. Para completar un piso entero antes de moverse hacia arriba, comience configurando la coordenada Y en el primer bucle más exterior.

Bajo la función makeCube(), crea un bucle para establecer cómo alto cada cubo aparece.
- Variable de control : heightIndex = 1
- Punto final : TOWER_SIZE
- Dentro del bucle, añadir: local spawnY = (heightIndex - 1) * CUBE_SIZE
```
-- Construye torre
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end
```
La calculación de spawnY se asegura de que el primer cubo aparezca a la altura 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 1 debe restarse del heightIndex .

Con el primer bucle para la altura terminado, comience en el segundo. Dentro del primer bucle para, agregue un nuevo bucle para donde 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 añadir: 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 incrustado. Esto ayuda a que su código sea legible y organizado.

Dentro del bucle segundo , agregue un tercer para el bucle para la torre ancho . En este bucle final, llame a makeCube() y pase en los parámetros X, Y, Z.

Variable de control : widthIndex = 1
Punto final : TOWER_SIZE
Dentro del bucle añadir:
- local spawnZ = widthIndex * CUBE_SIZE
- makeCube(spawnX, spawnY, spawnZ)
- Un tiempo de espera de 0.25 para que puedas ver cómo se construye la torre.


-- Construye 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 sea de un color aleatorio, cambia currentColor a números aleatorios RGB 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

Ejecute el proyecto y espere a ver que se ha creado una torre completa sin ningún error en la ventana de salida.

Desafíos Opcionales

A continuación se muestran diferentes desafíos autodirigidos que usan bucles anidados de diferentes maneras. Inténtalo y codifica por tu cuenta antes de mirar la solución.

Desvanecer Partes

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

La solución del código está abajo.


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

Objetos de lluvia

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

Por tu en posesión, ve si puedes:

Crea un objeto a partir de las partes básicas. Asegúrate de soldar todas las partes juntas para que el objeto no se caiga a pedazos.
Coloca el objeto en ServerStorage
Modifica el PartMaker que se encuentra en el Ejemplo de bucle anidado para usar tu objeto en lugar de las partes.

Una muestra se muestra aquí.

Se incluye una solución de código que usa magdalenas.


local numberOfBatches = 30
local cupcakesPerBatch = 6

local cupcakesBaked = 0

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


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

    -- Lazo interno
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("Inner loop: cupcake " .. cupcakeNumber)
        -- Muffins de pista horneados
        cupcakesBaked += 1
        task.wait(0.5)
    end

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

Resumen

Para realizar tareas más complejas, los codificadores encontrarán útil combinar múltiples bucles e incluso diferentes tipos de bucles. Todos los bucles pueden estar 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 exterior, ejecuta tareas a través de bucles internos y luego vuelve al primer bucle si aplicable.