Boucles imbriquées | Documentation

Imbriquer des boucles vous permet de répéter des tâches par lots. Par exemple, cuire trois lots de six cupcakes, ou attribuer des armes à des joueurs dans deux équipes.

Comment fonctionnent les boucles imbriquées

Lorsque des boucles sont imbriquées, les scripts s'exécutent ligne par ligne jusqu'à atteindre la prochaine boucle. La boucle intérieure s'exécutera jusqu'à ce que sa condition soit remplie avant de revenir à la boucle extérieure.

Logique de boucle imbriquée

Le diagramme suivant montre les étapes qu'une boucle prend.

Boucle extérieure : le code s'exécute ligne par ligne jusqu'à atteindre la boucle intérieure.
Boucle extérieure : le code s'exécute ligne par ligne jusqu'à atteindre la boucle intérieure.
Boucle extérieure : le code s'exécute ligne par ligne jusqu'à atteindre la boucle intérieure.

Exemple de boucle imbriquée

Les boucles imbriquées peuvent sembler quelque peu abstraites, donc un exemple visuel peut aider. Pour cet exercice, copiez et collez un script d'exemple et exécutez-le dans Studio. Ce script va créer des tours de pièces. La boucle extérieure contrôlera combien de pièces faire, tandis que la boucle intérieure créera le véritable lot.

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


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

-- Crée un cube unique
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 intérieure
  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 un lot différent de pièces colorées. Après avoir traversé un lot, il fera une pause de 2 secondes. La déclaration print dans la boucle extérieure s'exécutera une seule fois par boucle intérieure terminée.

Tour de boucle for imbriquée

Chaque boucle a son propre ensemble de code, il peut donc être responsable de tâches différentes. Une chose que les boucles imbriquées peuvent faire est de changer l'emplacement où un objet apparaît pour créer une tour comme celle dans cette vidéo. Il y a trois boucles différentes, chacune contrôlant où le cube apparaît le long de la largeur, de la longueur et de la hauteur de la tour.

Code d'un script de générateur de cubes

Pour pratiquer les boucles imbriquées, vous allez créer un script qui génère 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 cette fonction plusieurs fois.

Configurez le script

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 cette fonction plusieurs fois.

Supprimez le script PartMaker ou désactivez-le (dans les propriétés du script, cochez Désactivé). Sinon, il y aura deux scripts créant des pièces en même temps au même endroit.
Créez un nouveau script nommé TowerBuilder. Ajoutez des variables pour la taille de la tour et la taille des cubes en haut.
```
local TOWER_SIZE = 4
local CUBE_SIZE = 2
```
Remarquez comment les variables ci-dessus sont toutes en majuscules. Ce sont ce qu'on appelle des constantes, ou des variables qui ne changent pas. Pour les distinguer des variables qui seront modifiées dans le script, tapez-les en utilisant des majuscules et des underscores.

Ajoutez une fonction locale nommée makeCube() qui crée un unique cube carré 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 à l'espace de travail afin qu'il apparaisse.


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 au final. Il est plus rapide de faire des modifications sur une instance avant qu'il n'y ait un objet physique dans le monde 3D.

Apparition dans différentes directions

Pour créer une tour, faites apparaître des cubes à des points spécifiques en réglant les propriétés X, Y, Z de chaque nouveau cube. X et Z sont latéraux. Y est en haut et en bas.

Dans makeCube(), ajoutez des paramètres pour spawnX, spawnY, et spawnZ. Ces nombres définiront l'emplacement 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

À l'intérieur de la fonction, définissez la propriété CFrame du cube à une nouvelle CFrame utilisant les paramètres 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

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.

Apparition avec des boucles imbriquées

Le script comportera trois boucles au total, une pour la longueur, une pour la largeur et une pour la hauteur de la tour. Pour compléter un étage entier avant de monter, commencez par définir la coordonnée Y dans la première boucle extérieure.

Sous la fonction makeCube(), créez une boucle for pour définir à quelle hauteur chaque cube apparaît.
- Variable de contrôle: heightIndex = 1
- Point de fin: TOWER_SIZE
- À l'intérieur de la boucle, ajoutez : local spawnY = (heightIndex - 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 à hauteur du sol et se déplace ensuite sur l'espace d'un seul cube à chaque fois. Le niveau du sol est à 0, c'est pourquoi 1 doit être soustrait de l'heightIndex.

Avec la première boucle pour la hauteur terminée, commencez sur la seconde. À l'intérieur de la première boucle for, ajoutez une nouvelle boucle for pour définir où placer le cube le long de la longueur de la tour.

Variable de contrôle: lengthIndex = 1
Point de fin: TOWER_SIZE
À l'intérieur de cette boucle ajoutez: 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

Lorsqu'on travaille avec des boucles imbriquées, il est important de s'assurer que le code est bien indenté. Cela aide à rendre votre code lisible et organisé.

À l'intérieur de la deuxième boucle, ajoutez une troisième boucle for pour la largeur de la tour. Dans cette boucle finale, appelez makeCube() et passez les paramètres X, Y, Z.

Variable de contrôle: widthIndex = 1
Point de fin: TOWER_SIZE
À l'intérieur de la boucle ajoutez :
- local spawnZ = widthIndex * CUBE_SIZE
- makeCube(spawnX, spawnY, spawnZ)
- Un temps d'attente de 0.25 pour que vous puissiez voir la tour se construire.


-- 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 ait une couleur aléatoire, modifiez currentColor en nombres RGB aléatoires dans la même boucle où vous créez un nouvel é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 de voir qu'une tour complète a été créée sans erreurs dans la fenêtre de sortie.

Défis optionnels

Ci-dessous se trouvent différents défis autodirigés qui utilisent des boucles imbriquées de différentes manières. Essayez de coder par vous-même avant de regarder la solution.

Faire disparaître les pièces

Alors que la tour est construite, faites disparaître les pièces en transparence de gauche à droite.

La solution 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 boucle en commençant par 0

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

Faire tomber des objets

Au lieu de pièces, essayez de faire apparaître un objet réel. L'exemple ici utilise des cupcakes.

Essayez par vous-même de :

Créer un objet à partir de pièces de base. Assurez-vous de souder toutes les pièces ensemble afin que l'objet ne se casse pas.
Placer l'objet dans ServerStorage
Modifier le PartMaker trouvé dans l'Exemple de boucle imbriquée pour utiliser votre objet au lieu de pièces.

Un échantillon est présenté ici.

Une solution code utilisant des cupcakes est incluse.


local numberOfBatches = 30
local cupcakesPerBatch = 6

local cupcakesBaked = 0

-- Crée un unique 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 intérieure
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("Inner loop: cupcake " .. cupcakeNumber)
        -- Suivi des cupcakes 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 codeurs trouveront utile de combiner plusieurs boucles, et même différents types de boucles. Toutes les boucles peuvent être imbriquées, ce qui signifie qu'une boucle est à l'intérieur d'une autre. Les boucles imbriquées suivent la même logique que toute autre boucle. Elle commence dans la première boucle extérieure, exécute des tâches à travers les boucles intérieures, puis revient à la première boucle si applicable.