Boucles imbriquées

*Ce contenu est traduit en utilisant l'IA (Beta) et peut contenir des erreurs. Pour consulter cette page en anglais, clique ici.

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

Comment les boucles nidées s'lancer

Lorsque les boucles sont imbriquées, les scripts vont ligne par ligne jusqu'à ce qu'ils atteignent la prochaine boucle.La boucle interne s'exécutera jusqu'à ce que sa condition soit satisfaite avant de retourner à la boucle extérieure.

Logique de boucle héritée

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

  • Boucle extérieure : le code s'exécute ligne par ligne jusqu'à ce qu'il atteigne la boucle interne.:
  • Boucle extérieure : le code s'exécute ligne par ligne jusqu'à ce qu'il atteigne la boucle interne.:
  • Boucle extérieure : le code s'exécute ligne par ligne jusqu'à ce qu'il atteigne la boucle interne.

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'échantillon et exécutez-le dans Studio.Ce script créera des tours de parties.La boucle extérieure contrôlera le nombre de parties à fabriquer, tandis que la boucle interne créera le lot réel.

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

    local numberOfBatches = 7

    local partsPerBatch = 5

    local partsMade = 0

    

    -- Fait 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

  2. Regardez le script générer une autre série de pièces colorées.Après avoir traversé une batch, elle s'arrêtera pendant 2 secondes.La déclaration d'impression dans la boucle extérieure s'exécutera une seule fois par boucle interne terminée.

Nesté pour la tour en boucle

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

Coder un script de créateur de cubes

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

Configurer le script

Pour le script de la tour en cube, codez d'abord une fonction qui génère un seul cube. La tour sera construite en appelant cette fonction à plusieurs reprises.

  1. Supprimer le script PartMaker ou le désactiver (dans les propriétés du script, vérifiez Désactivé).Si vous ne le faites pas, il y aura deux scripts qui fabriqueront des parties en même temps au même emplacement.

  2. Créez un nouveau script nommé TowerBuilder. Ajoutez des variables pour la taille de la tour et la taille du cube en haut.

    local TOWER_SIZE = 4

    local CUBE_SIZE = 2

  3. 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

  4. Définissez la couleur du cube à 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

  5. Enfin, parent le nouveau cube dans l'espace de travail pour 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

Apparaître dans différentes directions

Pour créer une tour, générez des cubes à des points spécifiques en définissant les propriétés X, Y, Z de chaque nouveau cube. X et Z sont côte à côte. Y est en haut et en bas.

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

  2. À l'intérieur de la fonction, définissez la propriété CFrame du cube sur une nouvelle CFrame en 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

Apparition avec des boucles imbriquées

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

  1. Sous la fonction makeCube(), créez une boucle for pour définir comment chaque cube apparaît haut .

    • Variable de contrôle : heightIndex = 1
    • Point d'extrémité : TOWER_SIZE
    • À l'intérieur de la boucle, ajouter: local spawnY = (index de hauteur - 1) * CUBE_SIZE
    -- Construit une tour

    for heightIndex = 1, TOWER_SIZE do

        local spawnY = (heightIndex - 1) * CUBE_SIZE

    end

  2. Avec la première boucle pour la hauteur terminée, commencez sur la deuxième.À l'intérieur de la première boucle while, ajoutez une nouvelle boucle while pour le lieu où placer le cube le long de la tour.

    • Variable de contrôle : lengthIndex = 1
    • Point d'extrémité : TOWER_SIZE
    • À l'intérieur de cette boucle, 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

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

    • Variable de contrôle : widthIndex = 1
    • Point d'extrémité : TOWER_SIZE
    • À l'intérieur de la boucle ajouter :
      • local spawnZ = widthIndex * CUBE_SIZE
      • makeCube(spawnX, spawnY, spawnZ)
      • Un temps d'attente de 0,25 pour que vous puissiez voir la tour être construite.
    -- Construit une 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

  4. Pour que chaque étage soit d'une couleur aléatoire, changez currentColor en nombres aléatoires RGB dans le même cycle dans lequel 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

  5. Exécutez le projet et attendez de voir qu'une tour complète a été créée sans aucune erreur dans la fenêtre de sortie.

Défis optionnels

Ci-dessous, différents défis autogérés qui utilisent des boucles imbriquées de différentes manières. Essayez et codez vous-même avant de regarder la solution.

Disparaître les parties

Comme la tour est construite, faites disparaître les parties en 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 une 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 de chaque boucle commençant à 0



        for widthIndex = 1, TOWER_SIZE do

            local spawnZ = widthIndex * CUBE_SIZE

            makeCube(spawnX, spawnY, spawnZ)

            task.wait(0.05)

        end

    end

end

Faire pleuvoir des objets

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

Par posséder, voyez si vous pouvez :

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

Un échantillon est montré 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

Sommaire

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 qu'une boucle est à l'intérieur d'une autre.Les boucles imbriquées suivent la même logique que toute autre boucle.Il commence dans la première boucle extérieure, exécute des tâches à travers des boucles internes, puis revient à la première boucle si applicable.

Précédent
Suivant