-- Bir üretici modülü, ProceduralModel'in içeriklerini nasıl oluşturduğunu tanımlayan bir ModuleScript'tir.
-- Detaylar için https://create.roblox.com/docs/reference/engine/classes/ProceduralModel adresine bakın.
--
-- Bir üretici olarak kullanılabilmesi için, ModuleScript'in iki alanı olan bir tablo döndürmesi gerekir:
--   * `Attributes`  - varsayılan değerlerin bulunduğu bir tablo. Her anahtar, bu üreticiyi kullanan her
--                     ProceduralModel üzerinde bir özellik olur. Kullanıcılar daha sonra bu
--                     özellikleri Properties panelinde ayarlayarak yeni girdilerle tekrar üretim yapabilir.
--   * `OnGenerate`  - motorun modelin içeriğini (yeniden) inşa etmek için çağırdığı bir fonksiyon.
--
-- Bu script veya konumlayışı hakkında özel olan bir şey yoktur. DataModel içinde herhangi bir yerde
-- yaşayabilir ve ProceduralModel üzerindeki `Generator` özelliği buna işaret edilecek şekilde yeniden atanabilir.

-- Aşağıdaki tür açıklamaları isteğe bağlıdır ancak burada gerekli yapının açık olması için belgelenmiştir.

-- `GenerationFunctionParams`, her üretim çalıştığında `OnGenerate`'e geçirilir. Bu, şunları açığa çıkarır:
--   * `Attributes` - ProceduralModel üzerindeki mevcut özellik değerleri.
--   * `Size`       - oluşturulacak sınır hacmi (from `ProceduralModel.Size`).
--   * `Pause`      - kooperatif bekletme. Büyük generasyonların çağırma ipini tıkamaması için uzun döngüler içinde `parameters:Pause()` çağırın; motor daha sonra sizi yeniden başlatabilir.
type GenerationFunctionParams<Attributes> = {
	Attributes: Attributes,
	Size: Vector3,
	Pause: (self: GenerationFunctionParams<Attributes>) -> (),
}

-- `GeneratorModuleDefinition`, ModuleScript'in döndürmesi gereken tablodur.
-- `OnGenerate`, bir değer döndürmemelidir; bunun yerine oluşturulan örnekleri `targetContainer`'a ebeveyn yapın.
-- `targetContainer`'a (veya onun torunlarına) ebeveyn olan her şey üretimin çıktısı haline gelir.
type GeneratorModuleDefinition<Attributes> = {
	Attributes: Attributes,
	OnGenerate: (
		parameters: GenerationFunctionParams<Attributes>,
		targetContainer: GeneratedFolder
	) -> (),
}

-- Varsayılan özellikler. Buradaki her giriş, ProceduralModel üzerinde düzenlenebilir bir özellik olarak görünür.
-- Sabit bir `RandomSeed`, üretimi deterministik kılar: aynı girdiler her zaman aynı
-- çıktıyı üretir, bu önemlidir çünkü üretim, kullanıcı özellikleri düzenledikçe birçok kez çalışabilir.
local defaultAttributes = {
	BorderThickness = 1,
	RandomSeed = 142376088,
}

local Generator: GeneratorModuleDefinition<typeof(defaultAttributes)> = {
	Attributes = defaultAttributes,
	OnGenerate = function(parameters, targetContainer)
		-- Girdiler. `parameters.Attributes`, kullanıcının ayarladığı her şeyi yansıtır.
		-- ProceduralModel; `parameters.Size`, inşa edilecek sınır kutusudur.
		local borderThickness = parameters.Attributes.BorderThickness
		local random = Random.new(parameters.Attributes.RandomSeed)
		local size = parameters.Size

		-- Türev değerler. Yukarıdaki tohumlanmış `random`, bunları RandomSeed başına üretilebilir hale getirir.
		local minSize = math.min(size.X, size.Y, size.Z)
		local baseColor = Color3.fromHSV(random:NextNumber(0.5, 0.8), 0.7, 0.8)
		local outlineColor = Color3.fromHSV(random:NextNumber(), 0.4, 0.25)

		-- Aşağıdaki yapımda yukarıdan aşağıya okunabilirliği artırmak için küçük yardımcılar. Bir üretici yazmak için
		-- bu tür yardımcılar gerekmez; yalnızca tekrar sayısını azaltır.
		local function assignProperties(instance: Instance, properties: { [string]: unknown })
			-- Diğer özellikler yerinde olduğundan, Ebeveyn'i en son ayarlayın
			-- örnek DataModel'e girmeden önce ve Değişti olaylarını tetikler.
			for name, value in properties do
				if name ~= "Parent" then
					(instance :: any)[name] = value
				end
			end
			if properties.Parent ~= nil then
				instance.Parent = properties.Parent :: Instance
			end
			return instance
		end

		local function createInstance(className: string, properties: { [string]: unknown })
			return assignProperties(Instance.new(className), properties)
		end

		local function createPartWithDefaults(properties: { [string]: unknown })
			-- Oluşturulan parçalar genellikle sabitlenmiş ve çarpışmayan; gerektiğinde her parçayı geçersiz kılın.
			local part = createInstance("Part", {
				Anchored = true,
				CanCollide = false,
				Color = baseColor,
				Material = Enum.Material.SmoothPlastic,
				BottomSurface = Enum.SurfaceType.Smooth,
				TopSurface = Enum.SurfaceType.Smooth,
			})
			return assignProperties(part, properties)
		end

		-- Aşağıdaki her şey `targetContainer`'a ebeveyn yapar, bu da örneklerin
		-- üretilen çıktının parçası haline gelmesidir. Buraya ebeveyn olmayan örnekler atılır.

		-- Billboard adornee olarak kullanılan görünmez sınır parçası.
		local bounds = createPartWithDefaults({
			Name = "Bounds",
			Parent = targetContainer,
			Transparency = 1,
			Size = size,
		})

		-- Altında bir sınır dışı olan bir içe gömülü platform.
		local base = createPartWithDefaults({
			Name = "PlatformBase",
			Parent = targetContainer,
			Color = baseColor,
			CFrame = CFrame.new(0, (-size.Y + 1) / 2, 0),
			Size = Vector3.new(
				size.X - 2 * borderThickness,
				1.01,
				size.Z - 2 * borderThickness
			),
		})
		local outline = createPartWithDefaults({
			Name = "PlatformOutline",
			Parent = targetContainer,
			Color = outlineColor,
			Position = Vector3.yAxis * (-size.Y + 1) / 2,
			Size = Vector3.new(size.X, 1, size.Z),
		})

		-- "Merhaba Dünya!" billboard'u. Üreticiler herhangi bir örnek türünü oluşturabilir, yalnızca parça değil.
		local billboard = createInstance("BillboardGui", {
			Name = "Text",
			Parent = targetContainer,
			Adornee = bounds,
			LightInfluence = 0,
			Size = UDim2.fromScale(minSize, minSize),
		})
		local textLabel = createInstance("TextLabel", {
			Name = "HelloWorld",
			Parent = billboard,
			AnchorPoint = Vector2.new(0.5, 0.5),
			BackgroundTransparency = 1,
			Position = UDim2.fromScale(0.5, 0.5),
			Size = UDim2.fromScale(1, 1),
			Text = "Merhaba Dünya!",
			TextColor3 = baseColor,
			TextScaled = true,
			TextStrokeTransparency = 0,
		})
		local textStroke = createInstance("UIStroke", {
			Parent = textLabel,
			Color = outlineColor,
			Thickness = borderThickness * 3,
		})
	end,
}

-- Modül tanımını döndürmek, bu ModuleScript'in bir `Generator` olarak kullanılabilir olmasını sağlar.
return Generator

-- Bir üretici modülü, `Attributes` ve `OnGenerate` ile bir tablo döndüren bir ModuleScript'tir.
-- Bu ModuleScript'i bir ProceduralModel'in `Generator` özelliğine atamak, modelin
-- Boyutu, özellikleri veya modül kaynağı değiştiğinde `OnGenerate`'i çalıştırır.
-- https://create.roblox.com/docs/reference/engine/classes/ProceduralModel adresine bakın.

local ClassicRobloxLadderGenerator = {}

-- Varsayılan özellik değerleri. Her anahtar, bu üreticiyi kullanan herhangi bir ProceduralModel'de düzenlenebilir
-- bir özellik haline gelir ve Özellikler panelinde Özellikler altında görünür. Bunlardan herhangi birini
-- düzenlemek, yeni değerlerle `OnGenerate`'i tekrar çalıştırır.
ClassicRobloxLadderGenerator.Attributes = {
	RungSpacing = 2,
	RungThickness = 1,
	PostSize = 1,
	Color = Color3.new(0.5, 0.3, 0),
}

-- `OnGenerate`, motor tarafından modelin içeriğini oluşturmak için çağrılır.
-- Sözleşme:
--   * `parameters.Size`       - içinde inşa edilecek sınır kutusu (`ProceduralModel.Size`'dan).
--   * `parameters.Attributes` - ProceduralModel üzerindeki mevcut özellik değerleri.
--   * `parameters:Pause()`    - işbirlikçi yield; uzun döngüler içinde çağrılır,
--                               böylece büyük üretimlerin iptal olmasını önler.
--   * `targetContainer`       - buraya (veya varislerine) eklenecek her şey çıktı haline gelir.
--   * `OnGenerate`'den bir değer döndürmeyin; çıktılar `targetContainer` üzerinden iletilir.
ClassicRobloxLadderGenerator.OnGenerate = function(parameters, targetContainer)
	local size = parameters.Size
	local rungThickness = parameters.Attributes.RungThickness
	local postSize = parameters.Attributes.PostSize
	local count = (size.Y - rungThickness) // parameters.Attributes.RungSpacing + 1

	local function createPart(position, size)
		local part = Instance.new("Part")
		part.Size = size
		part.Position = position
		part.Anchored = true
		part.Color = parameters.Attributes.Color
		part.TopSurface = Enum.SurfaceType.Smooth
		part.BottomSurface = Enum.SurfaceType.Smooth
		-- `targetContainer` içine ebeveynlik yapmak, parçayı oluşturulan çıktıya ekler.
		part.Parent = targetContainer
	end

	-- Alt sınır kutusundan yukarı doğru yığılmış basamaklar.
	local position = Vector3.new(0, -size.Y / 2 + rungThickness / 2, 0)
	for i = 1, count do
		-- Bir basamak arasında bekleyerek çok sayıda basamağa sahip bir merdivenin iptal edilmesini önleyin.
		parameters:Pause()
		createPart(position, Vector3.new(size.X - 2 * postSize, rungThickness, size.Z))
		position += Vector3.new(0, parameters.Attributes.RungSpacing, 0)
	end

	-- Tam yükseklik boyunca uzanan sol ve sağ yan direkler.
	createPart(Vector3.new(-0.5 * size.X + postSize / 2, 0, 0), Vector3.new(postSize, size.Y, size.Z))
	createPart(Vector3.new(0.5 * size.X - postSize / 2, 0, 0), Vector3.new(postSize, size.Y, size.Z))
end

-- Modül tanımını döndürmek, bu ModuleScript'in `Generator` olarak kullanılmasını sağlar.
return ClassicRobloxLadderGenerator

local proceduralModel = ...
proceduralModel:SetAttribute("ThrowAnError", true) --> Kasıtlı olarak başarısız
print(proceduralModel:WaitForGenerationAsync()) --> false