Ciclos de Nesting | Documentación del Centro de creación de Roblox

Las macetas de repetición te permiten repetir tareas en lotes. Por ejemplo, hornear tres macetas de seis magdalenas o asignar armas a los jugadores en dos equipos.

Cómo se ejecutan los ciclos de nido

Cuando los bucles se aniden, los scripts van de línea en línea hasta que llegue al siguiente bucle. El bucle interior se ejecutará hasta que se cumpla su condición antes de volver al bucle exterior.

Lógica de cadenas de flujo anidadas

El siguiente diagrama muestra los pasos que sigue un ciclo.

Loop exterior: el código se ejecuta en línea hasta que llegue al loop exterior.
Loop exterior: el código se ejecuta en línea hasta que llegue al loop exterior.
Loop exterior: el código se ejecuta en línea hasta que llegue al loop exterior.

Ejemplo de Loop Nido

Los ciclos anidados pueden parecer algo abstractos, por lo que un ejemplo visual puede ayudar. Para este ejercicio, copia y pegue un script de ejemplo y ejécútalo en Studio. Este script creará torres de partes. El ciclo exterior controlará la cantidad de partes para hacer, mientras que el ciclo interior creará el conjunto de actualizaciones.

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 cubo único
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

-- Círculo 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))

  -- Ciclo 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 mientras el script genera un nuevo lote de partes de colores. Después de pasar por un lote, se detendrá por 2 segundos. La declaración de impresión en la declaración de círculo exterior solo se ejecutará una vez por cada lote completado.

Torre de For Loop Nestado

Cada bucle tiene su propio conjunto de código, por lo que puede ser responsable de diferentes tareas. Una de las cosas que los bucles anidados pueden hacer es cambiar el lugar donde se genera un objeto para crear una torre como la de este video. Hay tres diferentes bucles, uno para cada función de control de dónde se genera el cubo.

Codificación de un guión de creador de cubos

Para practicar ciclos de práctica, harás un script que crea una torre de cubos. Para el script de torre de cubos, primero códido una función que genera un solo cubo. La torre se construirá al hacer clic repetidamente en esta función.

Configurando el Script

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

Elimina el script PartMaker o desactivarlo (en las propiedades del script, checa 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
```
Nota cómo las variables de arriba están todas 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.

Añade una función local nombrada 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 a una variable que se actualizará en los ciclos de subida.


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

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

Generando 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 están al lado. Y está hacia arriba y hacia abajo.

En makeCube() , agregue parámetros para spawnX , spawnY y 1> spawnZ1> . Estos números establecerán la ubicació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

En la función, establece la propiedad CFrame del cubo en un nuevo CFrame usando los parámetros spawnX, spawnY, y 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 que se utiliza para almacenar la posición y orientación 3D. Se utiliza para colocar objetos en un mundo.

Generando con Ciclos Nidos

El script tendrá tres ciclos totales, uno para la longitud, ancho y altura de la torre. Para completar un piso entero antes de moverse hacia arriba, comience con la configuración de la Y en el primer círculo exterior.

Bajo la función makeCube(), crea un for para establecer cómo alto cada cube spawns.
- Variable de control : heightIndex = 1
- Final punto : TOWER_SIZE
- Dentro del bucle, añadir: local spawnY = (alturaIndex - 1) * CUBE_SIZE
```
-- Construye una torre
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end
```
La calculadora para spawnY asegura que el primer cubo se genera en la altura del suelo y luego se mueve a través del espacio de un solo cubo cada vez. El nivel del suelo es de 0, por lo que 1 se debe restar del heightIndex .

Con el primer bucle para la altura terminado, comienza en el segundo. Dentro del primer para el bucle, agrega un nuevo para el bucle para que se coloque el cubo a lo largo de la torre.

Control de variable : lengthIndex = 1
Final punto : 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

Cuando trabaja con ciclos de subida, es importante asegurarse de que el código esté bien alineado. Esto ayuda a hacer que su código sea legible y organizado.

Dentro del segundo ciclo, agrega un tercer ciclo para el ancho de la torre 幅 . En este ciclo final, llama makeCube() y pase en los parámetros X, Y, Z.

Variable de control : widthIndex = 1
Final punto : TOWER_SIZE
Dentro del bloque de añadir:
- local spawnZ = widthIndex * CUBE_SIZE
- makeCube(spawnX, spawnY, spawnZ)
- Un tiempo de espera de 0.25 para que pueda ver la torre construida.


-- Construye una 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 un color aleatorio, cambia currentColor a aleatorios RGB números en la misma ronda en la 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

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

Desafíos opcionales

A continuación, hay diferentes desafíos de autogestión que usan ciclos de repetición en diferentes formas. Intenta y códigate por tu propia cuenta antes de mirar la solución.

Desapariciendo Partes

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

La solución de código está 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 una 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 que comienza 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, intente generar un objeto real. El ejemplo aquí usó cupcakes.

Por ti en posesión, ve a ver si puedes:

Crea un objeto a partir de partes de base. Asegúrese de soldar todas las partes juntas para que el objeto no se derrumbe.
Coloca el objeto en el almacenamiento del servidor
Modifica el PartMaker que se encuentra en el ejemplo de ciclo anidoado para usar tu objeto en lugar de las partes.

Se muestra un ejemplo aquí.

Se incluye una solución de código que utiliza cupcakes.


local numberOfBatches = 30
local cupcakesPerBatch = 6

local cupcakesBaked = 0

--Hace un solo pastel de taza
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


-- Círculo 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))

    -- Ciclo interno
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("Inner loop: cupcake " .. cupcakeNumber)
        -- Rastrear muffins horneados
        cupcakesBaked += 1
        task.wait(0.5)
    end

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

Resumen

Para completar tareas más complejas, los codificadores encontrará útil combinar múltiples ciclos, y incluso diferentes tipos de ciclos. Todos los ciclos se pueden anidar, lo que significa que un ciclo está dentro de otro. Los ciclos anidados siguen la misma lógica que cualquier otro ciclo. Comienza en el primer, último ciclo, ejecuta tareas a través de ciclos internos, y luego ciclos de retorno a la primera oportunidad si es aplicable.