Zagnieżdżone pętle | Dokumentacja – Centrum twórców Roblox

Zagnieżdżanie pętli pozwala powtarzać zadania w partiach. Na przykład, piec trzy partie po sześć babeczek lub przypisywać bronie graczom w dwóch drużynach.

Jak działają zagnieżdżone pętle

Gdy pętle są zagnieżdżone, skrypty przechodzą linia po linii, aż do napotkania następnej pętli. Wewnętrzna pętla wykonuje się, aż spełniony zostanie warunek, zanim powróci do pętli zewnętrznej.

Logika zagnieżdżonej pętli

Poniższy diagram ilustruje kroki, które pętla podejmuje.

Pętla zewnętrzna: kod działa linia po linii, aż dotrze do pętli wewnętrznej.
Pętla zewnętrzna: kod działa linia po linii, aż dotrze do pętli wewnętrznej.
Pętla zewnętrzna: kod działa linia po linii, aż dotrze do pętli wewnętrznej.

Zagnieżdżone pętle mogą wydawać się nieco abstrakcyjne, więc wizualny przykład może pomóc. Na potrzeby tego ćwiczenia skopiuj i wklej przykładowy skrypt i uruchom go w Studio. Ten skrypt stworzy wieże części. Pętla zewnętrzna kontroluje, ile części ma zostać wykonanych, podczas gdy pętla wewnętrzna tworzy rzeczywistą partię.

Utwórz nowy skrypt w ServerScriptService o nazwie PartMaker. Skopiuj poniższy kod.


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

-- Tworzy pojedynczy sześcian
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

-- Pętla zewnętrzna
for partBatch = 1, numberOfBatches do
  print("Górna pętla zewnętrzna: part batch " .. partBatch)
  currentColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))

  -- Pętla wewnętrzna
  for partNumber = 1, partsPerBatch do
    createPart()
    print("Pętla wewnętrzna: część " .. partNumber)
    partsMade += 1
    task.wait(0.5)
  end

  print("Dolna pętla zewnętrzna: " .. partsMade .. " części wykonane jak dotąd.")

  task.wait(2)
end

Obserwuj, jak skrypt uruchamia różne partie kolorowych części. Po przejściu przez jedną partię, zatrzyma się na 2 sekundy. Instrukcja wydruku w pętli zewnętrznej będzie wykonana tylko raz na zakończoną pętlę wewnętrzną.

Wieża z zagnieżdżonymi pętlami for

Każda pętla ma swój własny zestaw kodu, więc może odpowiadać za różne zadania. Jedną z rzeczy, które mogą robić zagnieżdżone pętle, jest zmiana miejsca, w którym obiekt się spawia, aby stworzyć wieżę, jak w tym wideo. Istnieją trzy różne pętle, każda odpowiedzialna za kontrolowanie miejsca wzdłuż szerokości, długości i wysokości wieży, w której sześcian się spawia.

Kodu stwórcy sześcianów

Aby ćwiczyć zagnieżdżone pętle, stworzysz skrypt, który tworzy wieżę z sześcianów. Na początku skryptu z wieżą sześcianów, napisz funkcję, która spawia pojedynczy sześcian. Wieża będzie budowana przez wielokrotne wywoływanie tej funkcji.

Skonfiguruj skrypt

Dla skryptu wieży sześcianów najpierw napisz funkcję, która spawia pojedynczy sześcian. Wieża będzie budowana przez wielokrotne wywoływanie tej funkcji.

Usuń skrypt PartMaker lub wyłącz go (w właściwościach skryptu zaznacz Disabled). Jeśli tego nie zrobisz, będą dwa skrypty tworzące części w tym samym czasie w tym samym miejscu.
Utwórz nowy skrypt o nazwie TowerBuilder. Dodaj zmienne dla rozmiaru wieży i rozmiaru sześcianu na początku.
```
local TOWER_SIZE = 4
local CUBE_SIZE = 2
```
Zauważ, że zmienne powyżej są wszystkie wielkimi literami. Nazywa się je stałymi, czyli zmiennymi, które się nie zmieniają. Aby odróżnić je od zmiennych, które będą zmieniane w skrypcie, zapisuj je używając wielkich liter i podkreślników.

Dodaj lokalną funkcję o nazwie makeCube(), która tworzy pojedynczy kwadratowy sześcian korzystając z CUBE_SIZE.


local TOWER_SIZE = 4
local CUBE_SIZE = 2

-- Tworzy pojedyncze sześciany
local function makeCube()
  local cube = Instance.new("Part")
  cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
end

Ustaw kolor sześcianu na zmienną, która będzie aktualizowana w zagnieżdżonych pętlach.


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

Na koniec przypisz nowy sześcian do miejsca pracy, aby się pojawił.


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

W kodzie Roblox, po utworzeniu obiektu przez skrypt, zaleca się przypisanie go na końcu. Wprowadzenie zmian do instancji przed utworzeniem fizycznego obiektu w 3D jest szybsze.

Spawnowanie w różnych kierunkach

Aby stworzyć wieżę, spawnować sześciany w określonych punktach, ustawiając właściwości X, Y, Z każdego nowego sześcianu. X i Z odnoszą się do szerokości, a Y do wysokości.

W makeCube(), dodaj parametry spawnX, spawnY, i spawnZ. Te liczby ustawią każdy nowy sześcian w odpowiednim miejscu.


-- Tworzy pojedyncze sześciany
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

Wewnątrz funkcji, ustaw właściwość CFrame sześcianu na nowy CFrame za pomocą parametrów 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

W Robloxie, CFrame to typ danych używany do przechowywania pozycji i orientacji w 3D. Służy do umieszczania obiektów w świecie.

Spawnowanie z zagnieżdżonymi pętlami

Skrypt będzie miał trzy pętle całkowicie, po jednej dla długości, szerokości i wysokości wieży. Aby zakończyć całe piętro przed przesunięciem się w górę, zacznij od ustawienia współrzędnej Y w pierwszej, zewnętrznej pętli.

Pod funkcją makeCube() stwórz pętlę for, aby ustawić jak wysoko spawnować każdy sześcian.
- Zmienne kontrolne: heightIndex = 1
- Koniec: TOWER_SIZE
- Wewnątrz pętli dodaj: local spawnY = (heightIndex - 1) * CUBE_SIZE
```
-- Buduje wieżę
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end
```
Obliczenie dla spawnY zapewnia, że pierwszy sześcian jest spawnowany na wysokości ziemi i potem przesuwa się o przestrzeń jednego sześcianu za każdym razem. Poziom gruntu znajduje się na 0, dlatego trzeba odjąć 1 od heightIndex.

Gdy pierwsza pętla dotycząca wysokości jest gotowa, rozpocznij drugą. Wewnątrz pierwszej pętli for dodaj nową pętlę for dotyczącą tego, gdzie umieścić sześcian wzdłuż długości wieży.

Zmienne kontrolne: lengthIndex = 1
Koniec: TOWER_SIZE
Wewnątrz tej pętli dodaj: 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

Pracując z zagnieżdżonymi pętlami, ważne jest, aby kod był dobrze wcięty. To pomoże uczynić twój kod czytelnym i zorganizowanym.

Wewnątrz drugiej pętli dodaj trzecią pętlę for dla szerokości wieży. W tej ostatniej pętli wywołaj makeCube() i przekaż parametry X, Y, Z.

Zmienne kontrolne: widthIndex = 1
Koniec: TOWER_SIZE
Wewnątrz pętli dodaj:
- local spawnZ = widthIndex * CUBE_SIZE
- makeCube(spawnX, spawnY, spawnZ)
- Czas oczekiwania 0.25, abyś mógł obserwować budowę wieży.


-- Buduje wieżę
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

Aby każde piętro miało losowy kolor, zmień currentColor na losowe liczby RGB w tej samej pętli, w której tworzysz nowe piętro.


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

Uruchom projekt i poczekaj, by zobaczyć, że stworzona została pełna wieża bez błędów w oknie Wyjścia.

Opcjonalne wyzwania

Poniżej znajdują się różne wyzwania, które używają zagnieżdżonych pętli na różne sposoby. Spróbuj zakodować samodzielnie przed sprawdzeniem rozwiązania.

Znikające części

Podczas budowania wieży, spraw, aby części zanikały w przezroczystości od lewej do prawej.

Rozwiązanie kodu jest poniżej.


local TOWER_SIZE = 6
local CUBE_SIZE = 2

-- Tworzy pojedyncze sześciany
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 -- Ustawia przezroczystość
    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)
    cube.Parent = workspace
end

-- Buduje wieżę
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 -- Aktualizuje w każdej pętli zaczynając od 0

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

Deszcz obiektów

Zamiast części spróbuj spawnować rzeczywisty obiekt. Przykład powyżej używał babeczek.

Na własną rękę sprawdź, czy potrafisz:

Stworzyć obiekt z podstawowych części. Upewnij się, że wszystkie części są ze sobą połączone, aby obiekt się nie rozpadł.
Umieścić obiekt w ServerStorage
Zmodyfikować PartMaker w przykładzie z zagnieżdżoną pętlą, aby używał twojego obiektu zamiast części.

Przykład jest pokazany tutaj.

Rozwiązanie kodu używającego babeczek jest dołączone.


local numberOfBatches = 30
local cupcakesPerBatch = 6

local cupcakesBaked = 0

-- Tworzy pojedynczą babeczkę
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


-- Pętla zewnętrzna
for cupcakeBatch = 1, numberOfBatches do
    print("Górna pętla zewnętrzna: partia babeczek " .. 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))

    -- Pętla wewnętrzna
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("Pętla wewnętrzna: babeczka " .. cupcakeNumber)
        -- Śledzenie upieczonych babeczek
        cupcakesBaked += 1
        task.wait(0.5)
    end

    print("Dolna pętla zewnętrzna: " .. cupcakesBaked .. " babeczek upieczonych do tej pory.")
end

Podsumowanie

Aby osiągnąć bardziej złożone zadania, programiści uznają za pomocne łączenie wielu pętli, a nawet różnych typów pętli. Wszystkie pętle mogą być zagnieżdżane, co oznacza, że jedna pętla znajduje się wewnątrz drugiej. Zagnieżdżone pętle postępują zgodnie z tą samą logiką co każda inna pętla. Zaczynają w pierwszej, najbardziej zewnętrznej pętli, wykonują zadania przez wewnętrzne pętle, a następnie wracają do pierwszej pętli, jeśli jest to możliwe.