子循环

nest 允许您在批量中重复任务。例如，烘焙三个六个小蛋糕的批量，或将武器分配给两个团队的玩家。

如何使用递归循环

当循环中有子循环时，脚本从第一个子循环开始到达下一个子循环。内部循环将在满足条件后返回外部循环。

递归循环逻辑

下图显示循环的步骤。

外部循环：代码从行到行运行，直到它到达外部循环。 外部循环：代码从行到行运行，直到它到达外部循环。 外部循环：代码从行到行运行，直到它到达外部循环。 >

示例：递归循环

可能有一些抽象的概念，因此视觉示例可能有帮助。 对于此示例，复制并粘贴一个示例脚本，并在 Studio 中运行。 这个脚本将创建零件的塔。 外部循环将控制要制作的零件数量，而内部循环将创建实际的批量。

1. 在 ServerScriptService 中创建一个名为 PartMaker 的新脚本。复制以下代码。

   local numberOfBatches = 7
   local partsPerBatch = 5
   local partsMade = 0
   
   -- 单个立方体
   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
   
   -- 外部循环
   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))
   
     -- 内部循环
     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

2. 观看脚本生成不同批色零件。在通过一个批次后，它将暂停 2 秒。外部循环中的打印声明只会运行一次。

螺旋塔中套装

每个循环都有自己的代验证码集，因此可以为不同的任务负责。一个由循环堆叠加的事物可以改变对象生成的位置，例如在此视频中的塔。有三个不同的循环，其中一个用于控制宽度、长度和高度方向的方块在塔上生成的位置。

编写一个方块生成器脚本

要练习习惯并且创建一个塔形的方块，你会创建一个生成单个方块的脚本。塔形方块的脚本由重复调用这个函数来建造。

设置脚本

对于方块塔脚本，首先，代码一个函数生成一个单个方块。塔将通过重复调用此函数来建造。

1. 删除 零件制作脚本或禁用它（在脚本属性中，检查是否禁用）。如果您未禁用，将在同一场景置同时有两个制作零件的脚本。

2. 创建一个名为 TowerBuilder 的新脚本。在顶部添加塔的大小和方块的大小。

   local TOWER_SIZE = 4
   local CUBE_SIZE = 2

   注意上面的变量都是大写。这些变量被称为 常量 或不会更改的变量。要将它们区分于在脚本中更改的变量，请使用大写和下划线使用。

3. 添加一个名为 makeCube() 的本地函数，该函数使用 CUBE_SIZE 创建一个单个方形立方体。

   local TOWER_SIZE = 4
   local CUBE_SIZE = 2
   
   -- 创建个人的方块
   local function makeCube()
     local cube = Instance.new("Part")
     cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
   end

4. 将 cube 的颜色设置为变量，将在递归循环中更新。

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

5. 最后， 父 新的方块到工作区，以便它们显示。

   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

   在 Roblox 代验证码中，当脚本创建对象时，建议在其父对象。它是在游戏世界中有物理对象之前更快地进行更改的。

在不同的方向生成

要创建一个塔，请在每个新的方块上设置 X、Y、Z 属性。 X 和 Z 是侧面。 Y 是上下。

1. 在 makeCube() 中，为 spawnX 、 spawnY 和 1> spawnZ1> 添加参数。这些数字将设置每个新的方块的生成地点。

   -- 创建个人的方块
   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

2. 在函数中，使用 spawnX 、 spawnY 、 spawnZ 参数设置立方体的 CFrame 属性为新的 CFrame。

   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

   在 Roblox 中，CFrame 是用于存储 3D 位置和方向的数据类型。它用于将对象放置在世界中。

生成时有巢状循环

脚本将有三个循环总共，其中一个用于塔的长度、宽度和高度。要完成向上移动前的整个楼层，请从第一个、最外部的循环开始。

1. 在 makeCube() 函数下，创建一个 for 循环，以确定每个立方体生成时发生的高度。

   • 控制变量 : heightIndex = 1
   • 结束点 : TOWER_SIZE
   • 在循环中，添加： local spawnY = (高度Index - 1) * CUBE_SIZE

   -- 建造塔
   for heightIndex = 1, TOWER_SIZE do
       local spawnY = (heightIndex - 1) * CUBE_SIZE
   end

   计算为 spawnY 确保第一个立方体在地面高度生成，然后每次移动在单个立方体的空间。地面高度为 0，因此 1 必须从 heightIndex 中减去 1。

2. 与高度第一循环完成后，开始第二个。在第一个循环内，添加一个新的循环，以便放置方块在塔长度方向的长度上。

   • 控制变量 : 长度索引 = 1
   • 结束点 : TOWER_SIZE
   • 在该循环中添加： 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

   当使用循环时，请确保代码的内容是清晰的。这使您的代码更易于读取和组织。

3. 在 第二个 循环内，为塔的 宽度 添加一个 第三个 。在这个最终循环中，调用1> makeCube()1>并通过 X、Y、Z 参数传入。

   • 控制变量 : widthIndex = 1
   • 结束点 : TOWER_SIZE
   • 在循环内添加：

     • local spawnZ = widthIndex * CUBE_SIZE
     • makeCube(spawnX, spawnY, spawnZ)
     • 等待时间 0.25 秒，让您可以看到塔被建成。

   -- 建造塔
   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

4. 要使每个楼层都是随机颜色，请将 currentColor 变更为随机 RGB 数量在同一循环中创建新楼层。

   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

5. 运行项目，并等待在输出窗口中创建一个完整的塔。

可选挑战

以下是使用不同的自导式挑战，使用不同的方法来使用堆叠循环。尝试在自己的代码上，然后再查看解决方案。

渐变零件

当塔被建成时，零件的透明度从左到右逐渐消失。

代码解决方案在下面。

local TOWER_SIZE = 6
local CUBE_SIZE = 2

-- 创建个人的方块
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 -- 设置透明度
    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)
    cube.Parent = workspace
end

-- 建造塔
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 --每个循环开始时更新 0

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

降雨物体

相反，试着生成一个实例对象。 此示例使用了 cupcakes。

独拥有，看看你可以：

• 从基础部件中创建一个对象。请确保焊接所有部件，以确保对象不会分裂。
• 将对象放入 ServerStorage
• 修改 嵌套循环示例 中找到的 PartMaker 来使用您的对象而不是零件。

这里有一个示例。

包含使用杯子蛋糕的代码解决方案。

local numberOfBatches = 30
local cupcakesPerBatch = 6

local cupcakesBaked = 0

--作出一个单个杯子蛋糕
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


-- 外部循环
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))

    -- 内部循环
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("Inner loop: cupcake " .. cupcakeNumber)
        -- 已烤制轨道松饼
        cupcakesBaked += 1
        task.wait(0.5)
    end

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

概要

为了实现更复杂的任务，编程人员发现它有助于结合多个循环和甚至不同类型的循环。 所有循环都可以被 nested，这意味着一个循环在另一个循环中。 嵌套循环按照相同的逻辑运行任务通过内部循环，然后回到第一个循环，如果适用。