-- Modul generator adalah sebuah ModuleScript yang mendefinisikan bagaimana SkripModel Prosedural membangun isinya.
-- Lihat https://create.roblox.com/docs/reference/engine/classes/ProceduralModel untuk detailnya.
--
-- Untuk digunakan sebagai generator, ModuleScript harus mengembalikan tabel dengan dua bidang:
--   * `Attributes`  - tabel nilai default. Setiap kunci menjadi atribut di setiap
--                     SkripModel Prosedural yang menggunakan generator ini. Pengguna kemudian dapat menyesuaikan
--                     atribut ini di panel Properties untuk menjalankan kembali generasi dengan input baru.
--   * `OnGenerate`  - fungsi yang dipanggil mesin untuk (re)membangun isi model.
--
-- Tidak ada yang istimewa tentang skrip ini atau penempatannya. Itu dapat berada di mana saja dalam DataModel
-- dan properti `Generator` pada SkripModel Prosedural dapat dipindahkan untuk menunjuk kepadanya.

-- Anotasi tipe di bawah ini bersifat opsional tetapi didokumentasikan di sini agar bentuk yang diperlukan jelas.

-- `GenerationFunctionParams` diteruskan ke `OnGenerate` setiap kali generasi dijalankan. Ini mengekspos:
--   * `Attributes` - nilai atribut saat ini pada SkripModel Prosedural.
--   * `Size`       - volume batas untuk dihasilkan (dari `ProceduralModel.Size`).
--   * `Pause`      - sebuah yield kooperatif. Panggil `parameters:Pause()` di dalam loop panjang supaya generasi yang besar
--                    tidak menghentikan thread pemanggil; mesin mungkin melanjutkan Anda nanti.
type GenerationFunctionParams<Attributes> = {
	Attributes: Attributes,
	Size: Vector3,
	Pause: (self: GenerationFunctionParams<Attributes>) -> (),
}

-- `GeneratorModuleDefinition` adalah tabel yang harus dikembalikan oleh ModuleScript.
-- `OnGenerate` tidak boleh mengembalikan nilai; pekerjaan yang dihasilkan dikategorikan kepada `targetContainer` sebagai gantinya.
-- Segala sesuatu yang menjadi bagian dari `targetContainer` (atau keturunannya) menjadi output dari generasi.
type GeneratorModuleDefinition<Attributes> = {
	Attributes: Attributes,
	OnGenerate: (
		parameters: GenerationFunctionParams<Attributes>,
		targetContainer: GeneratedFolder
	) -> (),
}

-- Atribut default. Setiap entri di sini muncul sebagai atribut yang dapat diedit pada SkripModel Prosedural.
-- `RandomSeed` tetap membuat generasi deterministik: masukan yang sama selalu menghasilkan yang sama
-- output, yang penting karena generasi dapat terjadi berkali-kali saat pengguna mengedit properti.
local defaultAttributes = {
	BorderThickness = 1,
	RandomSeed = 142376088,
}

local Generator: GeneratorModuleDefinition<typeof(defaultAttributes)> = {
	Attributes = defaultAttributes,
	OnGenerate = function(parameters, targetContainer)
		-- Input. `parameters.Attributes` mencerminkan apapun yang telah diatur pengguna pada
		-- SkripModel Prosedural; `parameters.Size` adalah kotak batas untuk dibangun.
		local borderThickness = parameters.Attributes.BorderThickness
		local random = Random.new(parameters.Attributes.RandomSeed)
		local size = parameters.Size

		-- Nilai yang diperoleh. `random` yang diberi benih di atas membuat ini dapat direproduksi per RandomSeed.
		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)

		-- Pembantu kecil untuk membuat konstruksi di bawah ini dibaca dari atas ke bawah. Anda tidak perlu
		-- pembantu seperti ini untuk menulis generator; mereka hanya mengurangi pengulangan.
		local function assignProperties(instance: Instance, properties: { [string]: unknown })
			-- Setel Parent terakhir agar properti lain berada di tempat sebelum instance memasuki
			-- DataModel dan memicu acara Changed.
			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 })
			-- Bagian yang dihasilkan biasanya terikat dan tidak bertabrakan; override per-bagian sesuai kebutuhan.
			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

		-- Semuanya di bawah ini menjadi bagian dari `targetContainer`, yang merupakan cara instance menjadi
		-- bagian dari output yang dihasilkan. Instance yang tidak menjadi bagian di sini akan dibuang.

		-- Bagian batas tak terlihat digunakan sebagai billboard adornee.
		local bounds = createPartWithDefaults({
			Name = "Bounds",
			Parent = targetContainer,
			Transparency = 1,
			Size = size,
		})

		-- Platform yang terbenam dengan garis batas di bawahnya.
		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),
		})

		-- "Halo Dunia!" billboard. Generator dapat membuat jenis instance apa pun, bukan hanya bagian.
		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 = "Halo Dunia!",
			TextColor3 = baseColor,
			TextScaled = true,
			TextStrokeTransparency = 0,
		})
		local textStroke = createInstance("UIStroke", {
			Parent = textLabel,
			Color = outlineColor,
			Thickness = borderThickness * 3,
		})
	end,
}

-- Mengembalikan definisi modul inilah yang menjadikan ModuleScript ini dapat digunakan sebagai `Generator`.
return Generator

-- Modul generator adalah ModuleScript yang mengembalikan tabel dengan `Attributes` dan `OnGenerate`.
-- Menetapkan ModuleScript ini ke properti `Generator` dari ProceduralModel menjalankan `OnGenerate`
-- setiap kali ukuran model, atribut, atau sumber modul berubah.
-- Lihat https://create.roblox.com/docs/reference/engine/classes/ProceduralModel.

local ClassicRobloxLadderGenerator = {}

-- Nilai atribut default. Setiap kunci menjadi atribut yang dapat diedit di ProceduralModel mana pun yang
-- menggunakan generator ini, dan muncul di panel Properti Studio di bawah Attributes. Mengedit salah satu
-- dari mereka menjalankan kembali `OnGenerate` dengan nilai baru.
ClassicRobloxLadderGenerator.Attributes = {
	RungSpacing = 2,
	RungThickness = 1,
	PostSize = 1,
	Color = Color3.new(0.5, 0.3, 0),
}

-- `OnGenerate` dipanggil oleh mesin untuk membangun konten model.
-- Kontrak:
--   * `parameters.Size`       - kotak pembatas (dari `ProceduralModel.Size`) untuk dibangun di dalamnya.
--   * `parameters.Attributes` - nilai atribut saat ini pada ProceduralModel.
--   * `parameters:Pause()`    - yield kooperatif; panggil di dalam loop panjang sehingga generasi besar
--                               tidak menghambat thread.
--   * `targetContainer`       - apa pun yang diparent di sini (atau ke keturunan-nya) menjadi output.
--   * Jangan mengembalikan nilai dari `OnGenerate`; output disampaikan melalui `targetContainer`.
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
		-- Menambahkan ke `targetContainer` adalah yang menambah bagian ke output yang dihasilkan.
		part.Parent = targetContainer
	end

	-- Anak tangga, ditumpuk dari dasar kotak pembatas ke atas.
	local position = Vector3.new(0, -size.Y / 2 + rungThickness / 2, 0)
	for i = 1, count do
		-- Yield antar anak tangga sehingga tangga dengan banyak anak tangga tidak menghambat thread.
		parameters:Pause()
		createPart(position, Vector3.new(size.X - 2 * postSize, rungThickness, size.Z))
		position += Vector3.new(0, parameters.Attributes.RungSpacing, 0)
	end

	-- Tiang kiri dan kanan yang menjangkau seluruh tinggi.
	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

-- Mengembalikan definisi modul adalah yang membuat ModuleScript ini dapat digunakan sebagai `Generator`.
return ClassicRobloxLadderGenerator

local proceduralModel = ...
proceduralModel:SetAttribute("ThrowAnError", true) --> Gagal dengan sengaja
print(proceduralModel:WaitForGenerationAsync()) --> false