-- Un módulo generador es un ModuleScript que define cómo un ProceduralModel construye su contenido.
-- Consulta https://create.roblox.com/docs/reference/engine/classes/ProceduralModel para más detalles.
--
-- Para ser usado como un generador, el ModuleScript debe devolver una tabla con dos campos:
--   * `Attributes`  - una tabla de valores predeterminados. Cada clave se convierte en un atributo en cada
--                     ProceduralModel que usa este generador. Los usuarios pueden ajustar estos
--                     atributos en el panel de Propiedades para volver a ejecutar la generación con nuevas entradas.
--   * `OnGenerate`  - una función que el motor llama para (re)construir el contenido del modelo.
--
-- Nada sobre este script o su ubicación es especial. Puede estar en cualquier lugar del DataModel
-- y la propiedad `Generator` de un ProceduralModel se puede reasignar para apuntar a él.

-- Las anotaciones de tipo a continuación son opcionales pero están documentadas aquí para que la forma requerida sea explícita.

-- `GenerationFunctionParams` se pasa a `OnGenerate` cada vez que se ejecuta la generación. Expone:
--   * `Attributes` - los valores de atributo actuales en el ProceduralModel.
--   * `Size`       - el volumen de unión en el que generar (desde `ProceduralModel.Size`).
--   * `Pause`      - una pausa cooperativa. Llama a `parameters:Pause()` dentro de bucles largos para que generaciones grandes no detengan el hilo que llama; el motor puede reanudarte más tarde.
type GenerationFunctionParams<Attributes> = {
	Attributes: Attributes,
	Size: Vector3,
	Pause: (self: GenerationFunctionParams<Attributes>) -> (),
}

-- `GeneratorModuleDefinition` es la tabla que el ModuleScript debe devolver.
-- `OnGenerate` no debe devolver un valor; en su lugar, coloca las instancias generadas en `targetContainer`.
-- Cualquier cosa que se coloque en `targetContainer` (o sus descendientes) se convierte en la salida de la generación.
type GeneratorModuleDefinition<Attributes> = {
	Attributes: Attributes,
	OnGenerate: (
		parameters: GenerationFunctionParams<Attributes>,
		targetContainer: GeneratedFolder
	) -> (),
}

-- Atributos predeterminados. Cada entrada aquí aparece como un atributo editable en el ProceduralModel.
-- Un `RandomSeed` fijo mantiene la generación determinista: las mismas entradas siempre producen el mismo
-- salida, lo cual es importante porque la generación puede ejecutarse muchas veces mientras el usuario edita propiedades.
local defaultAttributes = {
	BorderThickness = 1,
	RandomSeed = 142376088,
}

local Generator: GeneratorModuleDefinition<typeof(defaultAttributes)> = {
	Attributes = defaultAttributes,
	OnGenerate = function(parameters, targetContainer)
		-- Entradas. `parameters.Attributes` refleja lo que el usuario ha establecido en el
		-- ProceduralModel; `parameters.Size` es la caja delimitadora para construir.
		local borderThickness = parameters.Attributes.BorderThickness
		local random = Random.new(parameters.Attributes.RandomSeed)
		local size = parameters.Size

		-- Valores derivados. El `random` sembrado arriba hace que estos sean reproducibles por 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)

		-- Pequeñas ayudas para hacer que la construcción a continuación se lea de arriba a abajo. No necesitas
		-- ayudas como estas para escribir un generador; simplemente reducen la repetición.
		local function assignProperties(instance: Instance, properties: { [string]: unknown })
			-- Establecer Parent al final para que otras propiedades estén en su lugar antes de que la instancia entre
			-- en el DataModel y dispare eventos Cambiados.
			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 })
			-- Las partes generadas normalmente están ancladas y no colisionan; reemplaza por parte según sea necesario.
			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

		-- Todo lo que está debajo se coloca en `targetContainer`, que es cómo las instancias se convierten
		-- en parte de la salida generada. Las instancias que no están anidadas aquí se descartan.

		-- Parte de unión invisible utilizada como el adornee del cartel.
		local bounds = createPartWithDefaults({
			Name = "Boundaries",
			Parent = targetContainer,
			Transparency = 1,
			Size = size,
		})

		-- Una plataforma empotrada con un contorno de borde debajo de ella.
		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),
		})

		-- "¡Hola Mundo!" cartel. Los generadores pueden crear cualquier tipo de instancia, no solo partes.
		local billboard = createInstance("BillboardGui", {
			Name = "Texto",
			Parent = targetContainer,
			Adornee = bounds,
			LightInfluence = 0,
			Size = UDim2.fromScale(minSize, minSize),
		})
		local textLabel = createInstance("TextLabel", {
			Name = "HolaMundo",
			Parent = billboard,
			AnchorPoint = Vector2.new(0.5, 0.5),
			BackgroundTransparency = 1,
			Position = UDim2.fromScale(0.5, 0.5),
			Size = UDim2.fromScale(1, 1),
			Text = "¡Hola Mundo!",
			TextColor3 = baseColor,
			TextScaled = true,
			TextStrokeTransparency = 0,
		})
		local textStroke = createInstance("UIStroke", {
			Parent = textLabel,
			Color = outlineColor,
			Thickness = borderThickness * 3,
		})
	end,
}

-- Devolver la definición del módulo es lo que hace que este ModuleScript sea utilizable como un `Generator`.
return Generator

-- Un módulo generador es un ModuleScript que devuelve una tabla con `Attributes` y `OnGenerate`.
-- Asignar este ModuleScript a la propiedad `Generator` de un ProceduralModel ejecuta `OnGenerate`
-- cada vez que el tamaño del modelo, los atributos o la fuente del módulo cambian.
-- Ver https://create.roblox.com/docs/reference/engine/classes/ProceduralModel.

local ClassicRobloxLadderGenerator = {}

-- Valores de atributo predeterminados. Cada clave se convierte en un atributo editable en cualquier ProceduralModel que
-- utilice este generador, y aparece en el panel de Propiedades del Estudio bajo Atributos. Editar cualquiera
-- de ellos vuelve a ejecutar `OnGenerate` con los nuevos valores.
ClassicRobloxLadderGenerator.Attributes = {
	RungSpacing = 2,
	RungThickness = 1,
	PostSize = 1,
	Color = Color3.new(0.5, 0.3, 0),
}

-- `OnGenerate` es llamado por el motor para construir el contenido del modelo.
-- Contrato:
--   * `parameters.Size`       - el cuadro delimitador (de `ProceduralModel.Size`) para construir dentro.
--   * `parameters.Attributes` - valores de atributo actuales en el ProceduralModel.
--   * `parameters:Pause()`    - rendimiento cooperativo; llama dentro de bucles largos para que grandes generaciones
--                               no bloqueen el hilo.
--   * `targetContainer`       - cualquier cosa que tenga como padre (o sus descendientes) se convierte en la salida.
--   * No devuelve un valor de `OnGenerate`; las salidas se comunican a través de `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
		-- La parentización en `targetContainer` es lo que añade la parte a la salida generada.
		part.Parent = targetContainer
	end

	-- Peldaños, apilados desde la parte inferior del cuadro delimitador hacia arriba.
	local position = Vector3.new(0, -size.Y / 2 + rungThickness / 2, 0)
	for i = 1, count do
		-- Rendir entre peldaños para que una escalera con muchos peldaños no bloquee el hilo.
		parameters:Pause()
		createPart(position, Vector3.new(size.X - 2 * postSize, rungThickness, size.Z))
		position += Vector3.new(0, parameters.Attributes.RungSpacing, 0)
	end

	-- Postes laterales izquierdo y derecho abarcando toda la altura.
	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

-- Devolver la definición del módulo es lo que hace que este ModuleScript sea utilizable como un `Generator`.
return ClassicRobloxLadderGenerator

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