-- Un modulo generatore è uno ScriptModulo che definisce come un ProceduralModel costruisce i suoi contenuti.
-- Vedi https://create.roblox.com/docs/reference/engine/classes/ProceduralModel per dettagli.
--
-- Per essere usato come generatore, lo ScriptModulo deve restituire una tabella con due campi:
--   * `Attributes`  - una tabella di valori predefiniti. Ogni chiave diventa un attributo su ogni
--                     ProceduralModel che utilizza questo generatore. Gli utenti possono quindi modificare questi
--                     attributi nel pannello Proprietà per rieseguire la generazione con nuovi input.
--   * `OnGenerate`  - una funzione che il motore chiama per (ri)costruire i contenuti del modello.
--
-- Nulla riguardo questo script o la sua posizione è speciale. Può vivere ovunque nel DataModel
-- e la proprietà `Generator` su un ProceduralModel può essere riassegnata per puntare a esso.

-- Le annotazioni di tipo qui sotto sono opzionali ma documentate affinché la forma richiesta sia esplicita.

-- `GenerationFunctionParams` viene passato a `OnGenerate` ogni volta che la generazione viene eseguita. Espone:
--   * `Attributes` - i valori attuali degli attributi sul ProceduralModel.
--   * `Size`       - il volume di delimitazione entro cui generare (da `ProceduralModel.Size`).
--   * `Pause`      - una sospensione cooperativa. Chiama `parameters:Pause()` all'interno di cicli lunghi affinché generazioni di grandi dimensioni non blocchino il thread chiamante; il motore potrebbe riprenderti più tardi.
type GenerationFunctionParams<Attributes> = {
	Attributes: Attributes,
	Size: Vector3,
	Pause: (self: GenerationFunctionParams<Attributes>) -> (),
}

-- `GeneratorModuleDefinition` è la tabella che lo ScriptModulo deve restituire.
-- `OnGenerate` non deve restituire un valore; invece, instaura le istanze generate all'interno di `targetContainer`.
-- Qualsiasi cosa parentata a `targetContainer` (o ai suoi discendenti) diventa l'output della generazione.
type GeneratorModuleDefinition<Attributes> = {
	Attributes: Attributes,
	OnGenerate: (
		parameters: GenerationFunctionParams<Attributes>,
		targetContainer: GeneratedFolder
	) -> (),
}

-- Attributi predefiniti. Ogni voce qui appare come un attributo modificabile sul ProceduralModel.
-- Un `RandomSeed` fisso mantiene la generazione deterministica: gli stessi input producono sempre lo stesso
-- output, il che è importante perché la generazione può essere eseguita molte volte mentre l'utente modifica le proprietà.
local defaultAttributes = {
	BorderThickness = 1,
	RandomSeed = 142376088,
}

local Generator: GeneratorModuleDefinition<typeof(defaultAttributes)> = {
	Attributes = defaultAttributes,
	OnGenerate = function(parameters, targetContainer)
		-- Input. `parameters.Attributes` riflette qualunque cosa l'utente abbia impostato sul
		-- ProceduralModel; `parameters.Size` è il riquadro illuminato da costruire.
		local borderThickness = parameters.Attributes.BorderThickness
		local random = Random.new(parameters.Attributes.RandomSeed)
		local size = parameters.Size

		-- Valori derivati. Il `random` seminato sopra rende questi ripetibili 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)

		-- Piccole funzioni ausiliarie per rendere la costruzione qui sotto leggibile dall'alto verso il basso. Non è necessario
		-- avere funzioni come queste per scrivere un generatore; servono soltanto per ridurre la ripetizione.
		local function assignProperties(instance: Instance, properties: { [string]: unknown })
			-- Imposta il Parent per ultimo in modo che altre proprietà siano al loro posto prima che l'istanza entri
			-- nel DataModel e attivi eventi 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 })
			-- Le parti generate sono tipicamente ancorate e non collidono; sostituisci per ogni parte come necessario.
			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

		-- Tutto ciò che segue viene parentato a `targetContainer`, che è come le istanze diventano
		-- parte dell'output generato. Le istanze non parentate qui vengono scartate.

		-- Parte di delimitazione invisibile utilizzata come adornee del cartellone.
		local bounds = createPartWithDefaults({
			Name = "Bounds",
			Parent = targetContainer,
			Transparency = 1,
			Size = size,
		})

		-- Una piattaforma incassata con un contorno di bordo sotto di essa.
		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),
		})

		-- Cartellone "Ciao Mondo!" I generatori possono creare qualsiasi tipo di istanza, non solo parti.
		local billboard = createInstance("BillboardGui", {
			Name = "Text",
			Parent = targetContainer,
			Adornee = bounds,
			LightInfluence = 0,
			Size = UDim2.fromScale(minSize, minSize),
		})
		local textLabel = createInstance("TextLabel", {
			Name = "CiaoMondo",
			Parent = billboard,
			AnchorPoint = Vector2.new(0.5, 0.5),
			BackgroundTransparency = 1,
			Position = UDim2.fromScale(0.5, 0.5),
			Size = UDim2.fromScale(1, 1),
			Text = "Ciao Mondo!",
			TextColor3 = baseColor,
			TextScaled = true,
			TextStrokeTransparency = 0,
		})
		local textStroke = createInstance("UIStroke", {
			Parent = textLabel,
			Color = outlineColor,
			Thickness = borderThickness * 3,
		})
	end,
}

-- Restituire la definizione del modulo è ciò che rende questo ScriptModulo utilizzabile come `Generator`.
return Generator

-- Un modulo generatore è un ModuleScript che restituisce una tabella con `Attributes` e `OnGenerate`.
-- Assegnare questo ModuleScript alla proprietà `Generator` di un ProceduralModel esegue `OnGenerate`
-- ogni volta che le dimensioni del modello, gli attributi o la sorgente del modulo cambiano.
-- Vedi https://create.roblox.com/docs/reference/engine/classes/ProceduralModel.

local ClassicRobloxLadderGenerator = {}

-- Valori degli attributi predefiniti. Ogni chiave diventa un attributo modificabile su qualsiasi ProceduralModel che
-- utilizza questo generatore, e appare nel pannello Proprietà di Studio sotto Attributi. Modificare qualsiasi
-- di essi riesegue `OnGenerate` con i nuovi valori.
ClassicRobloxLadderGenerator.Attributes = {
	RungSpacing = 2,
	RungThickness = 1,
	PostSize = 1,
	Color = Color3.new(0.5, 0.3, 0),
}

-- `OnGenerate` viene chiamato dal motore per costruire i contenuti del modello.
-- Contratto:
--   * `parameters.Size`       - il volume (da `ProceduralModel.Size`) in cui costruire.
--   * `parameters.Attributes` - valori degli attributi correnti sul ProceduralModel.
--   * `parameters:Pause()`    - cede cooperativamente; chiama all'interno di cicli lunghi affinché grandi generazioni
--                               non blocchino il thread.
--   * `targetContainer`       - qualsiasi cosa parentata qui (o alle sue discendenze) diventa l'output.
--   * Non restituire un valore da `OnGenerate`; gli output vengono comunicati tramite `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
		-- Il parenting in `targetContainer` è ciò che aggiunge la parte all'output generato.
		part.Parent = targetContainer
	end

	-- Gradini, impilati dalla parte inferiore del volume verso l'alto.
	local position = Vector3.new(0, -size.Y / 2 + rungThickness / 2, 0)
	for i = 1, count do
		-- Cedi tra i gradini affinché una scala con molti gradini non blocchi il thread.
		parameters:Pause()
		createPart(position, Vector3.new(size.X - 2 * postSize, rungThickness, size.Z))
		position += Vector3.new(0, parameters.Attributes.RungSpacing, 0)
	end

	-- Montanti sinistro e destro che coprono l'intera altezza.
	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

-- Restituire la definizione del modulo è ciò che rende questo ModuleScript utilizzabile come `Generator`.
return ClassicRobloxLadderGenerator

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