-- Un module générateur est un ModuleScript qui définit comment un ProceduralModel construit son contenu.
-- Voir https://create.roblox.com/docs/reference/engine/classes/ProceduralModel pour plus de détails.
--
-- Pour être utilisé comme générateur, le ModuleScript doit retourner une table avec deux champs :
--   * `Attributes`  - une table de valeurs par défaut. Chaque clé devient un attribut sur chaque
--                     ProceduralModel qui utilise ce générateur. Les utilisateurs peuvent alors modifier ces
--                     attributs dans le panneau Propriétés pour relancer la génération avec de nouvelles entrées.
--   * `OnGenerate`  - une fonction que le moteur appelle pour (re)construire le contenu du modèle.
--
-- Rien dans ce script ou son placement n'est spécial. Il peut se trouver n'importe où dans le DataModel
-- et la propriété `Generator` sur un ProceduralModel peut être réassignée pour pointer vers lui.

-- Les annotations de type ci-dessous sont optionnelles mais documentées ici afin que la forme requise soit explicite.

-- `GenerationFunctionParams` est passé à `OnGenerate` chaque fois que la génération s'exécute. Il expose :
--   * `Attributes` - les valeurs d'attribut actuelles sur le ProceduralModel.
--   * `Size`       - le volume de délimitation à générer (à partir de `ProceduralModel.Size`).
--   * `Pause`      - une pause coopérative. Appelez `parameters:Pause()` à l'intérieur de longues boucles pour que de grandes
--                    générations ne bloquent pas le thread appelant ; le moteur peut vous reprendre plus tard.
type GenerationFunctionParams<Attributes> = {
	Attributes: Attributes,
	Size: Vector3,
	Pause: (self: GenerationFunctionParams<Attributes>) -> (),
}

-- `GeneratorModuleDefinition` est la table que le ModuleScript doit retourner.
-- `OnGenerate` ne doit pas retourner de valeur ; parent les instances générées dans `targetContainer` à la place.
-- Tout ce qui est parenté à `targetContainer` (ou à ses descendants) devient la sortie de la génération.
type GeneratorModuleDefinition<Attributes> = {
	Attributes: Attributes,
	OnGenerate: (
		parameters: GenerationFunctionParams<Attributes>,
		targetContainer: GeneratedFolder
	) -> (),
}

-- Attributs par défaut. Chaque entrée ici apparaît comme un attribut modifiable sur le ProceduralModel.
-- Un `RandomSeed` fixe maintient la génération déterministe : les mêmes entrées produisent toujours les mêmes
-- sorties, ce qui est important car la génération peut s'exécuter plusieurs fois lorsque l'utilisateur modifie les propriétés.
local defaultAttributes = {
	BorderThickness = 1,
	RandomSeed = 142376088,
}

local Generator: GeneratorModuleDefinition<typeof(defaultAttributes)> = {
	Attributes = defaultAttributes,
	OnGenerate = function(parameters, targetContainer)
		-- Entrées. `parameters.Attributes` reflète ce que l'utilisateur a défini sur le
		-- ProceduralModel ; `parameters.Size` est la boîte englobante à construire.
		local borderThickness = parameters.Attributes.BorderThickness
		local random = Random.new(parameters.Attributes.RandomSeed)
		local size = parameters.Size

		-- Valeurs dérivées. Le `random` initialisé ci-dessus rend ces valeurs reproductibles par 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)

		-- Petits helpers pour rendre la construction ci-dessous lisible de haut en bas. Vous n'avez pas besoin
		-- d'aides comme celles-ci pour écrire un générateur ; elles réduisent simplement la répétition.
		local function assignProperties(instance: Instance, properties: { [string]: unknown })
			-- Définir le Parent en dernier pour que d'autres propriétés soient en place avant que l'instance n'entre
			-- dans le DataModel et déclenche les événements 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 })
			-- Les parties générées sont généralement ancrées et non-collidantes ; remplacez par partie si nécessaire.
			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

		-- Tout ce qui est ci-dessous est parenté dans `targetContainer`, ce qui est comment les instances deviennent
		-- partie de la sortie générée. Les instances non parentées ici sont ignorées.

		-- Partie de délimitation invisible utilisée comme l'adornee du billboard.
		local bounds = createPartWithDefaults({
			Name = "Bounds",
			Parent = targetContainer,
			Transparency = 1,
			Size = size,
		})

		-- Une plate-forme encastrée avec un contour de bord en dessous.
		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),
		})

		-- "Bonjour le Monde!" panneau d'affichage. Les générateurs peuvent créer n'importe quel type d'instance, pas seulement des parties.
		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 = "Bonjour le Monde!",
			TextColor3 = baseColor,
			TextScaled = true,
			TextStrokeTransparency = 0,
		})
		local textStroke = createInstance("UIStroke", {
			Parent = textLabel,
			Color = outlineColor,
			Thickness = borderThickness * 3,
		})
	end,
}

-- Retourner la définition du module est ce qui rend ce ModuleScript utilisable en tant que `Generator`.
return Generator

-- Un module générateur est un ModuleScript qui retourne une table avec `Attributes` et `OnGenerate`.
-- Assigner ce ModuleScript à la propriété `Generator` d'un ProceduralModel exécute `OnGenerate`
-- chaque fois que la taille du modèle, les attributs ou la source du module changent.
-- Voir https://create.roblox.com/docs/reference/engine/classes/ProceduralModel.

local ClassicRobloxLadderGenerator = {}

-- Valeurs par défaut des attributs. Chaque clé devient un attribut modifiable sur tout ProceduralModel qui
-- utilise ce générateur, et apparaît dans le panneau des Propriétés de Studio sous Attributs. Modifier l'un d'eux
-- relance `OnGenerate` avec les nouvelles valeurs.
ClassicRobloxLadderGenerator.Attributes = {
	RungSpacing = 2,
	RungThickness = 1,
	PostSize = 1,
	Color = Color3.new(0.5, 0.3, 0),
}

-- `OnGenerate` est appelé par le moteur pour construire le contenu du modèle.
-- Contrat :
--   * `parameters.Size`       - la boîte englobante (de `ProceduralModel.Size`) dans laquelle construire.
--   * `parameters.Attributes` - les valeurs d'attribut actuelles sur le ProceduralModel.
--   * `parameters:Pause()`    - cession coopérative ; appel à l'intérieur de longues boucles afin que les grandes générations
--                               ne bloquent pas le fil.
--   * `targetContainer`       - tout ce qui est parenté ici (ou à ses descendants) devient la sortie.
--   * Ne pas retourner de valeur depuis `OnGenerate` ; les sorties sont communiquées via `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
		-- Parentage dans `targetContainer` est ce qui ajoute la pièce à la sortie générée.
		part.Parent = targetContainer
	end

	-- Échelons, empilés du bas de la boîte englobante vers le haut.
	local position = Vector3.new(0, -size.Y / 2 + rungThickness / 2, 0)
	for i = 1, count do
		-- Céder entre les échelons pour qu'une échelle avec de nombreux échelons ne bloque pas le fil.
		parameters:Pause()
		createPart(position, Vector3.new(size.X - 2 * postSize, rungThickness, size.Z))
		position += Vector3.new(0, parameters.Attributes.RungSpacing, 0)
	end

	-- Poteaux latéraux gauche et droit s'étendant sur toute la hauteur.
	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

-- Retourner la définition du module est ce qui rend ce ModuleScript utilisable comme `Generator`.
return ClassicRobloxLadderGenerator

local proceduralModel = ...
proceduralModel:SetAttribute("ThrowAnError", true) --> Échouer délibérément
print(proceduralModel:WaitForGenerationAsync()) --> false