Versteckte Schleifen | Dokumentation

Nesting Loops ermöglichen es Ihnen, Aufgaben in mehreren Aufgaben zu wiederholen. Zum Beispiel das Backen von drei Cupcakes oder das Zuweisen von Waffen an Spieler auf zwei Teams.

Wie verschachtelte Loopläufe laufen

Wenn Loopings verschachtelt sind, werden Skripte von Zeile zu Zeile ausgeführt, bis es zum nächsten Looping gelangt. Der innere Loop wird ausgeführt, bis seine Bedingung erfüllt ist, bevor er zum äußeren Looping zurückkehrt.

Vererbte Loop-Logik

Das folgende Diagramm zeigt die Schritte, die ein Loop durchführt.

Außen-Loop: Code wird line by line ausgeführt, bis er den Innen-Loop erreicht.
Außen-Loop: Code wird line by line ausgeführt, bis er den Innen-Loop erreicht.
Außen-Loop: Code wird line by line ausgeführt, bis er den Innen-Loop erreicht.

Verbundenes Loop-Beispiel

Verzahnte Schleifen können etwas abstrakt wirken, so dass ein visuelles Beispiel helfensein kann. Für dieses Beispiel kopieren Sie ein Beispielskript und führen Sie es in Studio aus. Dieses Skript wird Tower von Teilen erstellen. Der äußere Loop steuert die Anzahl der Teile, während der innere Loop die tatsächliche Batch erstellt.

Erstellen Sie ein neues Skript in ServerScriptService namens PartMaker. Kopieren Sie den Code unten.


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

-- Erzeugt einen einzigen Würfel
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

-- Außerer Loop
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))

  -- Innerer Loop
  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

Beobachten Sie, wie das Skript eine andere Reihe von farbigen Teilen erzeugt. Nachdem es eine Reihe durchlaufen hat, wird es für 2 Sekunden angehalten. Die Druckanweisung in der äußeren Schleife wird nur einmal pro abgeschlossener innere Schleife ausgeführt.

Für Loop-Turm verschachtelt

Jeder Loop hat seine eigene Reihe von Codes, sodass er für verschiedene Aufgaben verantwortlich sein kann. Ein Ding, das Loop-Nester tun kann, ist, den Platz zu ändern, an dem ein Objekt spawnet, um einen Turm wie in diesem Video zu erstellen. Es gibt drei verschiedene Loop, eines für die Kontrolle, wo entlang der Breite, Länge und Höhe des Turms der Cube spawnet.

Coding eines Würfelschreibersripts

Um verdrehte Schleifen zu üben, wirst du ein Skript erstellen, das eine Tower of Cubes erstellt. Für den Skript, das. PL: die Skriptsmusst du zuerst einen Funktionscode aufrufen, der einen einzelnen Kubus erzeugt. Die Tower wird dann durch wiederholtes Aufrufen dieser Funktion gebaut.

Script einrichten

Für das Skript, das. PL: die Skripts, first code eine Funktion, die einen einzelnen Würfel erzeugt. Die Tower wird durch wiederholtes Aufrufen dieser Funktion gebaut.

Löschen Sie das PartMaker-Skript oder deaktivieren Sie es (in den Skript-Eigenschaften, überprüfen Sie Disabled). Wenn Sie nicht, wird es zwei Skripte geben, die Teile gleichzeitig am selben Ort erstellen.
Erstellen Sie ein neues Skript namens TowerBuilder. Fügen Sie Variablen für die Größe der Tur und die Cube-Größe oben hinzu.
```
local TOWER_SIZE = 4
local CUBE_SIZE = 2
```
Beachten Sie, wie die Variablen oben alle Großbuchstaben sind. Diese werden als Konstanten oder Variablen, die sich nicht ändern, benannt. Um sie von Variablen zu setzen, die innerhalb des Skript, das. PL: die Skriptsgeändert werden, verwenden Sie sie mit Großbuchstaben und Unterstrichen.

Füge eine lokale Funktion hinzu, die makeCube() nennt, die einen einzelnen Quadratwürfel erstellt, der CUBE_SIZE verwendet.


local TOWER_SIZE = 4
local CUBE_SIZE = 2

-- Erstellt einzelne Würfel
local function makeCube()
  local cube = Instance.new("Part")
  cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
end

Setzen Sie die Farbe des Würfels auf eine Variable, die in den verschachtelten Loop-Updates aktualisiert wird.


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

Zum Schluss, Eltern den neuen Cube in den Arbeitsbereich, damit er erscheint.


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

In Codeswird empfohlen, das Objekt am beendenzu übergeordnen. Es ist schneller, Änderungen an einer Instanz vorzunehmen, bevor ein physisches Objekt in der Weltvorhanden ist.

In verschiedenen Richtungen spawnen

Um einen Turm zu erstellen, spawnen Sie Würfel an bestimmten Punkten, indem Sie die X, Y und Z-Eigenschaften jedes neuen Würfels einstellen. X und Z sind seitlich. Y ist nach oben und unten.

In makeCube() fügen Sie spawnX , spawnY und 1> spawnZ1> Einstellungen hinzu. Diese Zahlen werden jeden neuen Würfel-Spawnort einstellen.


-- Erstellt einzelne Würfel
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

In der Funktion setzen Sie die CFrame-Eigenschaft des Cubes auf ein neues CFrame mit den spawnX, spawnY, spawnZ-Parametern.


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

In Roblox ist CFrame ein Datentyp, der 3D-Position und Ausrichtung speichert. Es wird verwendet, um Objekte in einer Welt zu platzieren.

Mit gestapelten Loops spawnen

Das Skript wird drei Loop-Total, eins für die Länge, Breite und Höhe des Turms. Um einen ganzen Stock vor dem Bewegen nach oben zu beenden, starten Sie mit der Einstellung der Y-Koordinate in der ersten, äußersten Loop.

Unter der makeCube()-Funktion, erstellen Sie einen for-Loop, um festzustellen, wie hoch hoch jedes Würfel-Spawns ist.
- Variable steuern : heightIndex = 1
- Endpunkt : TOWER_SIZE
- In der Schleife fügen Sie hinzufügen: lokale spawnY = (höheIndex - 1) * CUBE_SIZE
```
-- Baue den Turm
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end
```
Die Berechnung für spawnY sorgt dafür, dass der erste Würfel auf der Bodenhöhe spawnet und dann jedes Mal über die Größe eines einzelnen Würfels bewegt wird. Die Bodenebene beträgt 0, daher muss 1 vom heightIndex abgezogen werden.

Mit dem ersten Loop für die Höhe fertig, starten Sie auf dem zweiten. In dem ersten Loop für die Höhe fügen Sie einen neuen Loop hinzu, um den Kubus entlang der Höhe des Turms zu platzieren.

Variable Steuerelemente : lengthIndex = 1
Endpunkt : TOWER_SIZE
In diesem Loop hinzufügenSie hinzu: lokale 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

Wenn Sie mit verschachtelten Loopings arbeiten, ist es wichtig, sicherzustellen, dass der Code gut indenter ist. Dies hilft, Ihren Code lesbar und organisiert zu machen.

In der zweiten Loop fügen Sie einen dritten für die Loop für den Turm Breite hinzu. In dieser finalen Loop rufen Sie 1> makeCube()1> und übergeben Sie die X, Y, Z-Parameter.

Variable steuern : widthIndex = 1
Endpunkt : TOWER_SIZE
In den Loop hinzufügen:
- local spawnZ = widthIndex * CUBE_SIZE
- makeCube(spawnX, spawnY, spawnZ)
- Eine Wartezeit von 0,25 Sekunden, damit Sie die Turm aufbauen können.


-- Baue den Turm
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

Damit jede Etage eine zufällige Farbe ist, ändere currentColor in zufällige RGB -Zahlen im selben Loop, in dem du eine neue Etage erstellst.


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

Führen Sie das Projekt aus und warten Sie, bis eine vollständige Turm erstellt wurde, ohne irgendwelche Fehler im Ausgabe-Fenster zu sehen.

Optionale Herausforderungen

Dies sind verschiedene selbstgeführte Herausforderungen, die Loop-Stapel auf verschiedene Weise verwenden. Versuchen Sie, auf Ihrem eigenen Code, bevor Sie die Lösung betrachten.

Verbleibende Teile

Wenn der Turm gebaut ist, haben die Teile die Transparenz von links nach rechts verloren.

Die Code-Lösung ist unten.


local TOWER_SIZE = 6
local CUBE_SIZE = 2

-- Erstellt einzelne Würfel
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 -- Setzt Transparenz
    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)
    cube.Parent = workspace
end

-- Baue den Turm
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 --Aktualisiert jeden Loop, der bei 0 beginnt

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

Regen Sie Objekte nieder

Statt Teile versuche ein echtes Objekt zu spawnen. Das Beispiel hier verwendet Kekse.

Auf eigene besitzensehen, ob Sie:

Erstellen Sie ein Objekt aus Basisteilen. Stellen Sie sicher, dass Sie alle Teile zusammen schweißen, damit das Objekt nicht zerfällt.
Platziere das Objekt in ServerStorage
Modifizieren Sie den PartMaker, der in der Nested Loop Example gefunden ist, um Ihr Objekt anstelle von Teilen zu verwenden.

Ein Beispiel wird hier gezeigt.

Eine Code-Lösung mit Cupcakes ist enthalten.


local numberOfBatches = 30
local cupcakesPerBatch = 6

local cupcakesBaked = 0

--Macht einen einzelnen 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


-- Außerer Loop
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))

    -- Innerer Loop
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("Inner loop: cupcake " .. cupcakeNumber)
        -- Muffins schienen gebacken
        cupcakesBaked += 1
        task.wait(0.5)
    end

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

Zusammenfassung

Um komplexere Aufgaben zu erledigen, finden Coder es hilfreich, mehrere Loopings miteinander zu kombinieren, und sogar verschiedene Arten von Loopings. Alle Loopings können verschachtelt werden, was bedeutet, dass ein Looping in einem anderen Looping ist. Verbundene Loopings folgen der gleichen Logik wie alle anderen Loopings. Es beginnt in der ersten, äußersten Looping und führt Aufgaben durch Inner-Looping aus und schließt dann mit dem ersten Looping ab, wenn geltend.