Boucles imbriquées | Documentation

Les boucles de nidification vous permettent de répéter des tâches dans des lots. Par exemple, le fait de cuire trois lots de six cupcakes ou d'attribuer des armes aux joueurs sur deux équipes.

Comment les boucles imbriquées s'exécutent

Lorsque les boucles sont imbriquées, les scripts vont ligne par ligne jusqu'à ce qu'il atteigne le prochain boucle. Le boucle intérieur s'exécutera jusqu'à ce que sa condition soit remplie avant de revenir au boucle extérieur.

Logique de boucle imbriquée

Le tableau suivant montre les étapes qu'un boucle prend.

Loop extérieur : le code s'exécute en ligne par ligne jusqu'à ce qu'il atteigne le loop extérieur.
Loop extérieur : le code s'exécute en ligne par ligne jusqu'à ce qu'il atteigne le loop extérieur.
Loop extérieur : le code s'exécute en ligne par ligne jusqu'à ce qu'il atteigne le loop extérieur.

Exemple de boucle imbriquée

Les boucles imbriquées peuvent sembler un peu abstraites, alors un exemple visuel peut aider. Pour cet exercice, copiez et collez un script d'exemple et exécutez-le dans Studio. Ce script créera des tours de parties. La boucle extérieure contrôlera le nombre de parties à créer, tandis que la boucle intérieure créera le lot réel.

Créer un nouveau script dans ServerScriptService nommé PartMaker. Copiez le code ci-dessous.


local numberOfBatches = 7
local partsPerBatch = 5
local partsMade = 0

-- Crée un seul cube
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

-- Boucle extérieure
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))

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

Regardez le script générer une autre série de pièces de couleur. Après avoir terminé une série, il s'arrêtera pendant 2 secondes. La déclaration d'impression dans le boucle extérieure ne s'exécutera qu'une fois par boucle intérieure terminée.

Nesté pour la tour Loop

Chaque boucle a son propre ensemble de code, afin qu'elle puisse être responsable de différentes tâches. L'une des choses que les boucles imbriquées peuvent faire est de changer le placement d'où un objet apparaît pour créer une tour comme celle dans cette vidéo. Il y a trois boucles différentes, l'une pour contrôler où le long de la largeur, de la hauteur et de la hauteur d'un cône se trouve.

Programmer un script de créateur de cubes

Pour pratiquer des boucles imbriquées, vous ferez un script qui crée une tour de cubes. Pour le script de la tour de cubes, codez d'abord une fonction qui génère un seul cube. La tour sera construite en appelant répètitivement cette fonction.

Configurer le script

Pour le script de la tour cube, d'abord code une fonction qui génère un seul cube. La tour sera construite en appelant répètitivement cette fonction.

Supprimer le script PartMaker ou désactivez-le (dans les propriétés du script, vérifiez Désactivé). Si vous ne l'avez pas, il y aura deux scripts qui font des parties à la fois dans le même emplacement.
Créer un nouveau script nommé TowerBuilder. Ajoutez des variables pour la taille de la tour et la taille du cube au sommet.
```
local TOWER_SIZE = 4
local CUBE_SIZE = 2
```
Remarquez comment les variables ci-dessus sont toutes en majuscules. Ceux-ci sont appelés constantes , ou variables qui ne changent pas. Pour les distinguer des variables qui seront modifiés dans le script, écrivez-les en utilisant des majuscules et des tirets.

Ajoutez une fonction locale nommée makeCube() qui crée un seul cube carré en utilisant CUBE_SIZE.


local TOWER_SIZE = 4
local CUBE_SIZE = 2

-- Crée des cubes individuels
local function makeCube()
  local cube = Instance.new("Part")
  cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
end

Définissez la couleur du cube sur une variable qui sera mise à jour dans les boucles imbriquées.


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

Enfin, parent le nouveau cube dans l'espace de travail pour qu'il apparente.


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

Dans le code Roblox, une fois qu'un objet est créé par le script, il est recommandé de le parent à la terminer. Il est plus rapide de faire des modifications à une instance avant qu'il y ait un objet physique dans le monde du jeu.

Génération dans différentes directions

Pour créer une tour, faites apparaître des cubes à des endroits spécifiques en configurant les propriétés X, Y et Z de chaque nouveau cube. X et Z sont côté à côté. Y est vers le haut et vers le bas.

Dans makeCube() , ajouter des paramètres pour spawnX , spawnY et 1> spawnZ1> . Ces numéros définiront le lieu de génération de chaque nouveau cube.


-- Crée des cubes individuels
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

Dans la fonction, définissez la propriété CFrame du cube à un nouveau CFrame en utilisant les spawnX, spawnY, spawnZ paramètres.


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

Dans Roblox, CFrame est un type de données utilisé pour stocker la position et l'orientation 3D. Il est utilisé pour placer des objets dans un monde.

Génération avec des boucles imbriquées

Le script aura trois boucles totales, une pour la longueur, la largeur et la hauteur de la tour. Pour terminer un étage entier avant de déplacer vers le haut, commencez par définir la coordonnée Y dans le premier, le dernier boucle.

Sous la fonction makeCube(), créez un for loop pour définir comment haut chaque cube génère.
- Variable de contrôle : heightIndex = 1
- Fin du point : TOWER_SIZE
- Dans le loop, ajouter: local spawnY = (hauteurIndex - 1) * CUBE_SIZE
```
-- Construit la tour
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end
```
Le calcul pour spawnY s'assure que le premier cube apparaît à la hauteur au sol et se déplace ensuite sur l'espace d'un seul cube à la fois. Le niveau au sol est à 0, ce qui est pourquoi 1 doit être soustrait du heightIndex.

Avec la première boucle pour la hauteur terminée, commencez sur la deuxième. Dans la première boucle pour la boucle, ajoutez une nouvelle pour la boucle pour le lieu où se placer le cube le long de la longueur de la tour.

Variable de contrôle : longueurIndex = 1
Fin du point : TOWER_SIZE
Dans ce même loop, ajouter : 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

Lorsque vous travaillez avec des boucles imbriquées, il est important de vous assurer que le code est bien indépendant. Cela aide à rendre votre code lisible et organisé.

Dans le deuxième boucle, ajoutez un troisième pour le boucle pour la tour largeur . Dans ce boucle final, appelez 1> makeCube()1> et passez les paramètres X, Y, Z.

Variable de contrôle : widthIndex = 1
Fin du point : TOWER_SIZE
Dans le loop ajouter:
- local spawnZ = widthIndex * CUBE_SIZE
- makeCube(spawnX, spawnY, spawnZ)
- Un délai de 0,25 seconde pour que vous puissiez regarder la tour être construite.


-- Construit la tour
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

Pour que chaque étage soit une couleur aléatoire, modifiez currentColor pour des nombres aléatoires RGB dans le même script dans lequel vous créez un nouveau étage.


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

Exécutez le projet et attendez que une tour complète ait été créée sans aucun erreur dans la fenêtre de sortie.

Défis facultatifs

Ce sont ci-dessous différents défis de nature autonome qui utilisent des boucles imbriquées de différentes façons. Essayez de programmer par vous-même avant de regarder la solution.

Parties éloignées

À mesure que la tour est construite, faites disparaître les parties à travers la transparence de gauche à droite.

La solution de code est ci-dessous.


local TOWER_SIZE = 6
local CUBE_SIZE = 2

-- Crée des cubes individuels
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 -- Définit la transparence
    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)
    cube.Parent = workspace
end

-- Construit la tour
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 --Mises à jour à chaque début de boucle

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

Objets pleuvoir

Au lieu des parties, essayez de générer un objet réel. L'exemple ici a utilisé des cupcakes.

En posséder, voyez si vous pouvez :

Créez un objet à partir de pièces de base. Assurez-vous de souder toutes les pièces ensemble pour que l'objet ne tombe pas en pièces.
Placez l'objet dans ServerStorage
Modifiez le PartMaker trouvé dans l' exemple de boucle imbriquée pour utiliser votre objet au lieu des parties.

Une échantillon est affiché ici.

Une solution de code utilisant des cupcakes est incluse.


local numberOfBatches = 30
local cupcakesPerBatch = 6

local cupcakesBaked = 0

--Fait un seul cupcake
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


-- Boucle extérieure
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))

    -- Boucle interne
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("Inner loop: cupcake " .. cupcakeNumber)
        -- Muffins de piste cuits
        cupcakesBaked += 1
        task.wait(0.5)
    end

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

Résumé

Pour accomplir des tâches plus complexes, les développeurs trouveront utile de combiner plusieurs boucles, et même différents types de boucles. Toutes les boucles peuvent être imbriquées, ce qui signifie que l'un des boucles est à l'intérieur d'un autre. Les boucles imbriquées suivent la même logique que n'importe quel autre boucle. Ils commencent dans le premier, le boucle extérieure, exécute des tâches à travers des boucles intérieures, et puis retournent au premier boucle si applicable.