-- Một mô-đun tạo là một ModuleScript xác định cách mà một ProceduralModel xây dựng nội dung của nó.
-- Xem https://create.roblox.com/docs/reference/engine/classes/ProceduralModel để biết chi tiết.
--
-- Để được sử dụng như một mô-đun tạo, ModuleScript phải trả về một bảng với hai trường:
--   * `Attributes`  - một bảng các giá trị mặc định. Mỗi khóa trở thành một thuộc tính trên mỗi
--                     ProceduralModel sử dụng mô-đun tạo này. Người dùng có thể điều chỉnh các
--                     thuộc tính này trong bảng thuộc tính để tái tạo lại với các đầu vào mới.
--   * `OnGenerate`  - một hàm mà động cơ gọi để (tái) xây dựng nội dung của mô hình.
--
-- Không có gì đặc biệt về kịch bản hoặc vị trí của nó. Nó có thể ở bất kỳ đâu trong DataModel
-- và thuộc tính `Generator` trên một ProceduralModel có thể được gán lại để trỏ tới nó.

-- Các chú thích kiểu dưới đây là tùy chọn nhưng được tài liệu hóa ở đây để hình dạng yêu cầu rõ ràng.

-- `GenerationFunctionParams` được truyền cho `OnGenerate` mỗi lần thực hiện tạo. Nó tiết lộ:
--   * `Attributes` - các giá trị thuộc tính hiện tại trên ProceduralModel.
--   * `Size`       - khối lượng giới hạn để tạo bên trong (từ `ProceduralModel.Size`).
--   * `Pause`      - một yield hợp tác. Gọi `parameters:Pause()` trong các vòng lặp dài để các
--                    lần tạo lớn không làm đình trệ luồng gọi; động cơ có thể tiếp tục bạn sau.
type GenerationFunctionParams<Attributes> = {
	Attributes: Attributes,
	Size: Vector3,
	Pause: (self: GenerationFunctionParams<Attributes>) -> (),
}

-- `GeneratorModuleDefinition` là bảng mà ModuleScript phải trả về.
-- `OnGenerate` không được trả về giá trị; thay vào đó, các实例 đã được tạo ra sẽ được đặt vào `targetContainer`.
-- Bất kỳ thứ gì được đặt làm con của `targetContainer` (hoặc các phần tử con của nó) trở thành đầu ra của việc tạo.
type GeneratorModuleDefinition<Attributes> = {
	Attributes: Attributes,
	OnGenerate: (
		parameters: GenerationFunctionParams<Attributes>,
		targetContainer: GeneratedFolder
	) -> (),
}

-- Các thuộc tính mặc định. Mỗi mục ở đây xuất hiện như một thuộc tính có thể chỉnh sửa trên ProceduralModel.
-- Một `RandomSeed` cố định giữ cho việc tạo ra tính toán xác định: cùng một đầu vào luôn tạo ra cùng một
-- đầu ra, điều này rất quan trọng vì việc tạo có thể chạy nhiều lần khi người dùng chỉnh sửa các thuộc tính.
local defaultAttributes = {
	BorderThickness = 1,
	RandomSeed = 142376088,
}

local Generator: GeneratorModuleDefinition<typeof(defaultAttributes)> = {
	Attributes = defaultAttributes,
	OnGenerate = function(parameters, targetContainer)
		-- Đầu vào. `parameters.Attributes` phản ánh bất kỳ điều gì mà người dùng đã thiết lập trên
		-- ProceduralModel; `parameters.Size` là hộp giới hạn để xây dựng vào.
		local borderThickness = parameters.Attributes.BorderThickness
		local random = Random.new(parameters.Attributes.RandomSeed)
		local size = parameters.Size

		-- Các giá trị được tạo ra. `random` đã được seed ở trên làm cho những điều này có thể tái tạo theo mỗi 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)

		-- Các trợ giúp nhỏ để làm cho cấu trúc bên dưới dễ đọc từ trên xuống dưới. Bạn không cần
		-- các trợ giúp như vậy để viết một mô-đun tạo; chúng chỉ làm giảm sự lặp lại.
		local function assignProperties(instance: Instance, properties: { [string]: unknown })
			-- Đặt Parent cuối cùng để các thuộc tính khác có ở đó trước khi instance vào
			-- DataModel và kích hoạt sự kiện 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 })
			-- Các bộ phận được tạo ra thông thường được neo và không va chạm; ghi đè từng bộ phận khi cầ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

		-- Mọi thứ bên dưới được đặt làm con của `targetContainer`, đó là cách các instances trở thành
		-- một phần của đầu ra đã được tạo. Các instances không được đặt làm con ở đây sẽ bị loại bỏ.

		-- Phần giới hạn vô hình được sử dụng như là nơi quảng cáo.
		local bounds = createPartWithDefaults({
			Name = "Bounds",
			Parent = targetContainer,
			Transparency = 1,
			Size = size,
		})

		-- Một nền tảng lõm với một viền ở dưới nó.
		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),
		})

		-- "Xin chào Thế giới!" bảng quảng cáo. Các mô-đun tạo có thể tạo bất kỳ loại instance nào, không chỉ giới hạn ở các bộ phận.
		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 = "Xin chào Thế giới!",
			TextColor3 = baseColor,
			TextScaled = true,
			TextStrokeTransparency = 0,
		})
		local textStroke = createInstance("UIStroke", {
			Parent = textLabel,
			Color = outlineColor,
			Thickness = borderThickness * 3,
		})
	end,
}

-- Trả về định nghĩa mô-đun là điều làm cho ModuleScript này có thể sử dụng như một `Generator`.
return Generator

-- Một mô-đun tạo là một ModuleScript trả về một bảng với `Attributes` và `OnGenerate`.
-- Gán ModuleScript này cho thuộc tính `Generator` của ProceduralModel sẽ chạy `OnGenerate`
-- bất cứ khi nào kích thước, thuộc tính hoặc nguồn mô-đun của mô hình thay đổi.
-- Xem https://create.roblox.com/docs/reference/engine/classes/ProceduralModel.

local ClassicRobloxLadderGenerator = {}

-- Các giá trị thuộc tính mặc định. Mỗi khóa trở thành một thuộc tính có thể chỉnh sửa trên bất kỳ ProceduralModel nào
-- sử dụng bộ tạo này, và hiển thị trong bảng thuộc tính của Studio dưới Attributes. Chỉnh sửa bất kỳ
-- trong số chúng sẽ chạy lại `OnGenerate` với các giá trị mới.
ClassicRobloxLadderGenerator.Attributes = {
	RungSpacing = 2,
	RungThickness = 1,
	PostSize = 1,
	Color = Color3.new(0.5, 0.3, 0),
}

-- `OnGenerate` được gọi bởi engine để xây dựng nội dung của mô hình.
-- Hợp đồng:
--   * `parameters.Size`       - hộp giới hạn (từ `ProceduralModel.Size`) để xây dựng bên trong.
--   * `parameters.Attributes` - các giá trị thuộc tính hiện tại trên ProceduralModel.
--   * `parameters:Pause()`    - gián đoạn hợp tác; gọi bên trong những vòng lặp dài để các quá trình lớn
--                               không làm tắc nghẽn luồng.
--   * `targetContainer`       - bất cứ thứ gì được làm cha ở đây (hoặc đến các hậu duệ của nó) trở thành đầu ra.
--   * Không trả về giá trị từ `OnGenerate`; đầu ra được truyền đạt qua `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
		-- Việc làm cha vào `targetContainer` là thứ thêm phần này vào đầu ra được tạo ra.
		part.Parent = targetContainer
	end

	-- Các bậc, xếp chồng từ đáy của hộp giới hạn lên trên.
	local position = Vector3.new(0, -size.Y / 2 + rungThickness / 2, 0)
	for i = 1, count do
		-- Gián đoạn giữa các bậc để một cái thang với nhiều bậc không chặn luồng.
		parameters:Pause()
		createPart(position, Vector3.new(size.X - 2 * postSize, rungThickness, size.Z))
		position += Vector3.new(0, parameters.Attributes.RungSpacing, 0)
	end

	-- Các cột bên trái và bên phải trải dài toàn bộ chiều cao.
	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

-- Trả về định nghĩa mô-đun là điều làm cho ModuleScript này có thể sử dụng như một `Generator`.
return ClassicRobloxLadderGenerator

local proceduralModel = ...
proceduralModel:SetAttribute("ThrowAnError", true) --> Cố ý thất bại
print(proceduralModel:WaitForGenerationAsync()) --> false