İç İçe Döngüler | Dokümantasyon - Roblox Yaratıcı Merkezi

Döngüleri iç içe yerleştirmek, görevleri partiler halinde tekrar etmenizi sağlar. Örneğin, altışar adet üç parti kek pişirmek veya iki takım oyuncularına silah atamak.

İç içe döngüler nasıl çalışır

Döngüler iç içe yerleştirildiğinde, betikler bir satırdan bir satıra geçerek bir sonraki döngüye ulaşana kadar devam eder. İç döngü, koşulu karşılayana kadar çalışır, ardından dış döngüye geri döner.

İç içe döngü mantığı

Aşağıdaki diyagram, bir döngünün aldığı adımları gösterir.

Dış döngü: kod, iç döngüye ulaşana kadar satır satır çalışır.
Dış döngü: kod, iç döngüye ulaşana kadar satır satır çalışır.
Dış döngü: kod, iç döngüye ulaşana kadar satır satır çalışır.

İç içe döngüler biraz soyut görünebilir, bu nedenle görsel bir örnek yardımcı olabilir. Bu alıştırma için bir örnek betiği kopyalayıp yapıştırın ve Studio'da çalıştırın. Bu betik parçaların kulelerini oluşturacaktır. Dış döngü, kaç parça yapılacağını kontrol ederken, iç döngü gerçek partiyi oluşturacaktır.

ServerScriptService içinde PartMaker adında yeni bir betik oluşturun. Aşağıdaki kodu kopyalayın.


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

-- Tek bir küp oluşturur
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

-- Dış döngü
for partBatch = 1, numberOfBatches do
  print("Üst dış döngü: parça partisi " .. partBatch)
  currentColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))

  -- İç döngü
  for partNumber = 1, partsPerBatch do
    createPart()
    print("İç döngü: parça " .. partNumber)
    partsMade += 1
    task.wait(0.5)
  end

  print("Alt dış döngü: " .. partsMade .. " parça yapıldı.")

  task.wait(2)
end

Betiğin, farklı renk parçaların bir partisinin ortaya çıktığını izleyin. Bir parti tamamlandıktan sonra 2 saniye bekleyecektir. Dış döngüdeki print ifadesi, tamamlanan iç döngü başına yalnızca bir kez çalışacaktır.

İç içe for döngüsü kulesi

Her döngünün kendine ait bir kod seti vardır, bu nedenle farklı görevlerden sorumlu olabilirler. İç içe döngülerin yapabileceği şeylerden biri, bir nesnenin ortaya çıkma yerini değiştirerek, bu videodaki gibi bir kule oluşturmaktır. Kule boyunca genişlik, uzunluk ve yükseklik için ayrı döngüler vardır.

Bir küp yapıcı betiği kodlayın

İç içe döngüleri uygulamak için, bir küp kulesi oluşturan bir betik yazacaksınız. Küp kulesi betiği için, önce tek bir küp ortaya çıkaran bir işlev kodlayın. Kule, bu işlevin sürekli çağrılmasıyla inşa edilecektir.

Betiği kurun

Küp kulesi betiği için, önce tek bir küp ortaya çıkaran bir işlev kodlayın. Kule, bu işlevin sürekli çağrılmasıyla inşa edilecektir.

PartMaker betiğini silin veya kapatın (betik özelliklerinde, Disabled seçeneğini kontrol edin). Eğer bunu yapmazsanız, aynı yerde aynı anda iki betik parça üretecektir.
TowerBuilder adında yeni bir betik oluşturun. Üst kısımda kule boyutu ve küp boyutu için değişkenler ekleyin.
```
local TOWER_SIZE = 4
local CUBE_SIZE = 2
```
Yukarıdaki değişkenlerin hepsinin büyük harfle yazıldığını fark edin. Buna sabitler denir, yani değişmeyecek değişkenler. Betik içinde değiştirilecek değişkenlerden ayırt etmek için, bunları büyük harfler ve alt çizgilerle yazın.

makeCube() adında tek bir kare küp oluşturan yerel bir işlev ekleyin, bunu CUBE_SIZE kullanarak yapın.


local TOWER_SIZE = 4
local CUBE_SIZE = 2

-- Tekil küpleri oluşturur
local function makeCube()
  local cube = Instance.new("Part")
  cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
end

Küpün rengini, iç içe döngülerde güncellenen bir değişkene ayarlayın.


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

Son olarak, parent (ebeveyn) olarak yeni küpü workspace'e ekleyerek görünmesini sağlayın.


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

Roblox kodunda, bir nesne betik tarafından oluşturulduktan sonra, onu en son parent (ebeveyn) yapmak önerilir. 3D dünyada fiziksel bir nesne olmadan örneğe değişiklik yapmak daha hızlıdır.

Farklı yönlerde ortaya çıkarma

Bir kule oluşturmak için, her yeni küpün X, Y, Z özelliklerini ayarlayarak belirli noktalarda küpler oluşturun. X ve Z yan yana, Y yukarı ve aşağıdır.

makeCube() içinde, spawnX, spawnY ve spawnZ parametreleri ekleyin. Bu sayılar, her yeni küpün doğma konumunu ayarlayacaktır.


-- Tekil küpleri oluşturur
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

Fonksiyonun içinde, küpün CFrame özelliğini spawnX, spawnY, spawnZ parametrelerini kullanarak yeni bir CFrame'e ayarlayın.


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

Roblox'ta CFrame, 3D konum ve yönelimi depolamak için kullanılan bir veri türüdür. Nesneleri bir dünyada yerleştirmek için kullanılır.

İç içe döngülerle ortaya çıkarma

Betikte toplam üç döngü olacak; birisi kulelerin uzunluğu, biri genişliği, diğeri yüksekliği için. Tamamen bir kat bitirip yukarı çıkmadan önce, ilk dış döngüde Y koordinatını ayarlamaya başlayın.

makeCube() fonksiyonunun altında, her küpün ne kadar yüksek ortaya çıkacağını ayarlamak için bir for döngüsü oluşturun.
- Kontrol değişkeni: heightIndex = 1
- Bitiş noktası: TOWER_SIZE
- Döngünün içine, şöyle ekleyin: local spawnY = (heightIndex - 1) * CUBE_SIZE
```
-- Kuleyi inşa eder
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end
```
spawnY için yapılan hesaplama, ilk küpün yerden yükseklik olarak doğmasını sağlar ve ardından her seferinde bir küpün alanı boyunca hareket eder. Yer seviyesi 0, bu yüzden heightIndex'ten 1 çıkarılması gerekir.

Yükseklik için ilk döngü tamamlandıktan sonra, ikincisine başlayın. İlk for döngüsü içinde, küpün kule boyunca uzunluğunun nereye yerleştirileceğine dair yeni bir for döngüsü ekleyin.

Kontrol değişkeni: lengthIndex = 1
Bitiş noktası: TOWER_SIZE
Döngü içine ekleyin: 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

İç içe döngülerle çalışırken, kodun iyi bir şekilde girintili olduğundan emin olmak önemlidir. Bu, kodunuzu okunabilir ve düzenli hale getirir.

İkinci döngünün içinde, kule genişliğine yönelik üçüncü bir for döngüsü ekleyin. Bu son döngüde makeCube() çağrısını yapın ve X, Y, Z parametrelerini geçirin.

Kontrol değişkeni: widthIndex = 1
Bitiş noktası: TOWER_SIZE
Döngü içinde ekleyin:
- local spawnZ = widthIndex * CUBE_SIZE
- makeCube(spawnX, spawnY, spawnZ)
- Kule inşa edilirken izlemek için 0.25 bekleme süresi ekleyin.


-- Kuleyi inşa eder
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

Her katın rastgele bir renge sahip olmasını sağlamak için, currentColor'ı yeni bir kat oluşturduğunuz döngü içinde rastgele RGB sayıları olarak değiştirin.


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

Projeyi çalıştırın ve Hata Çıktısı penceresinde hata olmadan tam bir kule oluşturulduğunu görün.

Opsiyonel zorluklar

Aşağıda iç içe döngüleri farklı şekillerde kullanan farklı öz yönlendirmeli zorluklar bulunmaktadır. Çözümü görmeden önce kendi başınıza kodlamayı deneyin.

Parçaları silin

Kule inşa edilirken, parçaların sol taraftan sağa doğru şeffaflık kazanmasını sağlayın.

Kod çözümü aşağıdadır.


local TOWER_SIZE = 6
local CUBE_SIZE = 2

-- Tekil küpleri oluşturur
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 -- Şeffaflığı ayarlar
    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)
    cube.Parent = workspace
end

-- Kuleyi inşa eder
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 -- Her döngü başında 0'dan başlar

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

Nesneleri yağmur telle indirin

Parçalar yerine, gerçek bir nesne ortaya çıkarın. Örnekte burada kekler kullanılmıştır.

Kendi başınıza, şunları gerçekleştirmeye çalışın:

Temel parçalardan bir nesne oluşturun. Nesnenin dağılmaması için tüm parçaları kaynar hale getirin.
Nesneyi ServerStorage'da yerleştirin.
Parçalar yerine nesnenizi kullanmak için İç İçe Döngü Örneği içerisinde bulunan PartMaker'ı değiştirin.

Burada bir örnek gösterilmiştir.

Kekleri kullanan bir kod çözümü aşağıda verilmiştir.


local numberOfBatches = 30
local cupcakesPerBatch = 6

local cupcakesBaked = 0

-- Tek bir kek oluşturur
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


-- Dış döngü
for cupcakeBatch = 1, numberOfBatches do
    print("Üst dış döngü: kek partisi " .. 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))

    -- İç döngü
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("İç döngü: kek " .. cupcakeNumber)
        -- Pişirilen kekleri takip et
        cupcakesBaked += 1
        task.wait(0.5)
    end

    print("Alt dış döngü: " .. cupcakesBaked .. " kek pişirildi.")
end

Özet

Daha karmaşık görevleri başarmak için, programcılar birden fazla döngüyü birleştirmenin ve hatta farklı türden döngüleri kullanmanın faydalı olduğunu bulacaklardır. Tüm döngüler iç içe yerleştirilebilir, yani bir döngü başka bir döngünün içinde olabilir. İç içe döngüler, diğer döngülerle aynı mantığı izler. İlk dış döngüde başlar, iç döngüler aracılığıyla görevleri yürütür ve eğer uygunsa, ilk döngüye geri döner.