-- Moduł generatora to ModuleScript, który definiuje, jak ProceduralModel buduje swoje treści.
-- Zobacz https://create.roblox.com/docs/reference/engine/classes/ProceduralModel, aby uzyskać szczegóły.
--
-- Aby być używanym jako generator, ModuleScript musi zwrócić tabelę z dwoma polami:
--   * `Attributes`  - tabela z domyślnymi wartościami. Każdy klucz staje się atrybutem na każdym
--                     ProceduralModel, które korzysta z tego generatora. Użytkownicy mogą następnie dostosować te
--                     atrybuty w panelu Właściwości, aby ponownie uruchomić generację z nowymi danymi wejściowymi.
--   * `OnGenerate`  - funkcja, którą silnik wywołuje, aby (ponownie) zbudować zawartość modelu.
--
-- Nic w tym skrypcie lub jego umiejscowieniu nie jest specjalne. Może znajdować się wszędzie w DataModel
-- i właściwość `Generator` w ProceduralModel może być przypisana z powrotem, aby na nią wskazywała.

-- Poniższe adnotacje typów są opcjonalne, ale dokumentowane tutaj, aby wymagana struktura była jawna.

-- `GenerationFunctionParams` jest przekazywane do `OnGenerate` za każdym razem, gdy uruchamiana jest generacja. Udostępnia:
--   * `Attributes` - bieżące wartości atrybutów na ProceduralModel.
--   * `Size`       - objętość graniczną, w której ma być wykonane generowanie (z `ProceduralModel.Size`).
--   * `Pause`      - współpraca w yielded. Wywołaj `parameters:Pause()` wewnątrz długich pętli, aby duże
--                    generacje nie zatrzymywały wątku wywołującego; silnik może wznowić cię później.
type GenerationFunctionParams<Attributes> = {
	Attributes: Attributes,
	Size: Vector3,
	Pause: (self: GenerationFunctionParams<Attributes>) -> (),
}

-- `GeneratorModuleDefinition` to tabela, którą ModuleScript musi zwrócić.
-- `OnGenerate` nie może zwracać wartości; zamiast tego rodzic generowane instancje w `targetContainer`.
-- Wszystko, co jest rodzicem do `targetContainer` (lub jego potomków), staje się wynikiem generacji.
type GeneratorModuleDefinition<Attributes> = {
	Attributes: Attributes,
	OnGenerate: (
		parameters: GenerationFunctionParams<Attributes>,
		targetContainer: GeneratedFolder
	) -> (),
}

-- Domyślne atrybuty. Każdy wpis tutaj pokazuje się jako edytowalny atrybut na ProceduralModel.
-- Ustalony `RandomSeed` utrzymuje generację deterministyczną: te same dane wejściowe zawsze produkują te same
-- wyjście, co jest ważne, ponieważ generacja może uruchamiać się wiele razy, gdy użytkownik edytuje właściwości.
local defaultAttributes = {
	BorderThickness = 1,
	RandomSeed = 142376088,
}

local Generator: GeneratorModuleDefinition<typeof(defaultAttributes)> = {
	Attributes = defaultAttributes,
	OnGenerate = function(parameters, targetContainer)
		-- Dane wejściowe. `parameters.Attributes` odzwierciedla, co użytkownik ustawił na
		-- ProceduralModel; `parameters.Size` to pudełko graniczne, w które ma być zbudowane.
		local borderThickness = parameters.Attributes.BorderThickness
		local random = Random.new(parameters.Attributes.RandomSeed)
		local size = parameters.Size

		-- Wartości pochodne. Zasiana `random` powyżej sprawia, że są one reprodukowalne dla 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)

		-- Małe pomocniki, aby konstrukcja poniżej była czytelna od góry do dołu. Nie musisz
		-- pomocników takich jak te, aby napisać generator; po prostu zmniejszają powtórzenia.
		local function assignProperties(instance: Instance, properties: { [string]: unknown })
			-- Ustal ostatnie właściwość Parent, aby inne właściwości były na miejscu przed tym, jak instancja wejdzie
			-- do DataModel i wywoła zdarzenia zmiany.
			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 })
			-- Generowane części są zazwyczaj zakotwiczone i niekolidujące; nadpisz dla części w razie potrzeby.
			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

		-- Wszystko poniżej parentuje do `targetContainer`, co sprawia, że instancje stają się
		-- częścią generowanego wyniku. Instancje, które nie są tutaj przypisane, są odrzucane.

		-- Niewidoczna część graniczna używana jako billboard adornee.
		local bounds = createPartWithDefaults({
			Name = "Bounds",
			Parent = targetContainer,
			Transparency = 1,
			Size = size,
		})

		-- Wklęsła platforma z konturem na dole.
		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),
		})

		-- "Witaj Świecie!" billboard. Generatory mogą tworzyć każdy typ instancji, nie tylko części.
		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 = "Witaj Świecie!",
			TextColor3 = baseColor,
			TextScaled = true,
			TextStrokeTransparency = 0,
		})
		local textStroke = createInstance("UIStroke", {
			Parent = textLabel,
			Color = outlineColor,
			Thickness = borderThickness * 3,
		})
	end,
}

-- Zwrócenie definicji modułu to to, co sprawia, że ten ModuleScript może być używany jako `Generator`.
return Generator

-- Moduł generatora to ModuleScript, który zwraca tabelę z `Attributes` i `OnGenerate`.
-- Przypisanie tego ModuleScript do właściwości `Generator` ProceduralModel uruchamia `OnGenerate`
-- za każdym razem, gdy zmienia się rozmiar modelu, atrybuty lub źródło modułu.
-- Zobacz https://create.roblox.com/docs/reference/engine/classes/ProceduralModel.

local ClassicRobloxLadderGenerator = {}

-- Domyślne wartości atrybutów. Każdy klucz staje się edytowalnym atrybutem na dowolnym ProceduralModel,
-- który używa tego generatora i pojawia się w panelu właściwości Studio pod Atrybutami. Edytowanie któregokolwiek
-- z nich ponownie uruchamia `OnGenerate` z nowymi wartościami.
ClassicRobloxLadderGenerator.Attributes = {
	RungSpacing = 2,
	RungThickness = 1,
	PostSize = 1,
	Color = Color3.new(0.5, 0.3, 0),
}

-- `OnGenerate` jest wywoływane przez silnik do zbudowania zawartości modelu.
-- Umowa:
--   * `parameters.Size`       - pudełko ograniczające (z `ProceduralModel.Size`), w którym budujemy.
--   * `parameters.Attributes` - bieżące wartości atrybutów w ProceduralModel.
--   * `parameters:Pause()`    - współpraca yield; wywołanie w długich pętlach, aby duże generacje
--                               nie zatrzymywały wątku.
--   * `targetContainer`       - wszystko, co jest parentowane tutaj (lub do jego potomków), staje się wynikiem.
--   * Nie zwracaj wartości z `OnGenerate`; wyniki są przekazywane przez `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
		-- Parentowanie do `targetContainer` to to, co dodaje część do wygenerowanego wyniku.
		part.Parent = targetContainer
	end

	-- Szczeble, układane od dołu pudełka ograniczającego w górę.
	local position = Vector3.new(0, -size.Y / 2 + rungThickness / 2, 0)
	for i = 1, count do
		-- Wstrzymanie między szczeblami, aby drabina z wieloma szczeblami nie blokowała wątku.
		parameters:Pause()
		createPart(position, Vector3.new(size.X - 2 * postSize, rungThickness, size.Z))
		position += Vector3.new(0, parameters.Attributes.RungSpacing, 0)
	end

	-- Lewy i prawy słupki na pełnej wysokości.
	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

-- Zwracanie definicji modułu sprawia, że ten ModuleScript jest użyteczny jako `Generator`.
return ClassicRobloxLadderGenerator

local proceduralModel = ...
proceduralModel:SetAttribute("ThrowAnError", true) --> Celowo nieudane
print(proceduralModel:WaitForGenerationAsync()) --> false