Nested Loops

Nesting loops allows you to repeat tasks in batches. For example, baking three batches of six cupcakes, or assigning weapons to players on two teams. When loops are nested, scripts go line by line until it reaches the next loop. The inner loop will run until it’s condition is met before returning to the outer loop.

How Nested Loops Run

Outer loop: code runs line-by-line until it reaches the inner loop.

Inner loop: runs until its condition is met. If the loop is set to run ten times, it'll run all ten times before returning to the outer loop.

Outer loop: runs remaining code before starting the cycle over again.

Cupcake Baker

If you wanted to code a game where players can bake multiple batches of cupcakes at a time, you can use one loop to control how many batches of cupcakes to make, and an inner loop to control how many cupcakes are made per batch. To see this in action, watch what happens with this script which makes squares instead of cupcakes.

1. Create a new script named cupcakeBaker. Copy the code below.

			
				cupcakeBaker
			
				Expected Output
			
				Expand
				
			local numberOfBatches = 7
local cupcakesPerBatch = 5
local cupcakesBaked = 0

-- Makes a single cupcake cube
local function bakeCupcake()
    local cupcake= Instance.new("Part")
    cupcake.Size = Vector3.new(2, 2, 2)
    cupcake.CFrame = CFrame.new(20, 0, 20)
    cupcake.Color = currentColor
    cupcake.Parent = workspace
end

-- Outer loop
for cupcakeBatch = 1, numberOfBatches do
    print ("Top outer loop: cupcake batch " .. cupcakeBatch)
    currentColor = Color3.fromRGB(math.random(0, 255),math.random(0, 255),math.random(0, 255))
    
    -- Inner loop
    for cupcakeNumber = 1, cupcakesPerBatch do    
        bakeCupcake()
        print("Inner loop: cupcake " .. cupcakeNumber)
        -- Track cupcakes baked
        cupcakesBaked = cupcakesBaked + 1
        wait(.5)
    end

    print("Bottom outer loop: " .. cupcakesBaked .. " cupcakes baked so far.")
end
		
				Copy Code
			
				Light Theme

Watch as different color square is spawned for every cupcake.

The print statement in the outer loop will run only one time per completed inner loop.

Nested For Loop Tower

Each loop has its own set of code, so can be responsible for different tasks. For example, instead of making the same cupcake, the outer loop changed the color of the cupcakes. One thing nested loops can do is change the placement of where an object spawns to create a tower like the one in this video. There’s three different loops, one each for controlling where along the width, length, and height of the tower the cube spawns.

Code the Cube Maker

For the cube tower script, first code a function that spawns a single cube. The tower will be built by repeatedly calling this function.

Delete the cupcakeBaker script or disable it. If you don’t, there’ll be two scripts making parts at the same time in the same place.

Create a new script named TowerBuilder. Add variables for tower size and cube size at the top.

local TOWER_SIZE = 4
local CUBE_SIZE = 2

Add a local function named makecube() that creates a single square cube using CUBE_SIZE.

local TOWER_SIZE = 4
local CUBE_SIZE = 2

-- Creates individual cubes
local function makecube()
   local cube = Instance.new("Part")
   cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
end

Set the cube’s color to a variable which will be updated in the nested loops.

local TOWER_SIZE = 4
local CUBE_SIZE = 2

-- Creates individual cubes
local function makecube()
   local cube = Instance.new("Part")
   cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
   cube.Color = currentColor
end

Lastly, parent the new cube to the workspace so it appears in game.

local TOWER_SIZE = 4
local CUBE_SIZE = 2

-- Creates individual cubes
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

Working in 3 Dimensions

The cupcakeBaker script had every cube spawn in the same location. As each new cube is made, previous cubes get pushed upwards, creating a mess. To create a tower, spawn cubes at specific points by setting the X, Y, Z properties of each new cube. X and Z are side to side. Y is up and down.

Add X,Y, and Z Parameters

Add parameters to makecube(), add parameters for spawnX, spawnY, and spawnZ. These numbers will set each new cube’s spawn location.

-- Creates individual cubes
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

Inside the function, set the cube’s CFrame property to a new CFrame using the spawnX, spawnY, spawnZ parameters.

-- Creates individual cubes
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

Spawn Cubes with Nested Loops

The script will have three loops total, one each for the length, width, and height of the tower. To complete an entire floor before moving upwards, start with setting the Y coordinate in the first, outermost loop.

Create a for loop to set how high each cube spawns.

Control variable: heightIndex = 1
End point: TOWER_SIZE
Inside the loop, add: local spawnY = (heightIndex - 1) * CUBE_SIZE

local TOWER_SIZE = 4
local CUBE_SIZE = 2
 
-- Creates individual cubes
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
 
-- Builds tower
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end

With the first loop for height finished, start on the second. Inside the first for loop, add a new for loop for where to place the cube along the length of the tower.

Control variable: lengthIndex = 1
End point: TOWER_SIZE
Inside that loop add: local spawnX = lengthIndex * CUBE_SIZE
Make sure that every level of your loop is nicely indented like below.

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

Inside the second loop, add a third for loop for the tower width. In this final loop, call makecube() and pass in the X,Y, Z parameters.

Control variable: widthIndex = 1
End point: TOWER_SIZE
Inside the loop add:
- local spawnZ = widthIndex * CUBE_SIZE
- makecube(spawnX, spawnY, spawnZ)
- A wait time of 0.25 so you can watch the tower be built.

-- Builds tower
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)
	    wait(0.25)
	end
    end
end

To have each floor be a random color, change currentColor to random rgb numbers in the same loop in which you create a new floor.

Completed Tower Builder Expected Output Expand

local TOWER_SIZE = 4
local CUBE_SIZE = 2
-- Creates individual cubes
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
-- Builds tower
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)
            wait(0.25)
        end
    end
end

Copy Code Light Theme

Tags:

coding
tutorials
loops
lua