-- Ein Generator-Modul ist ein ModuleScript, das definiert, wie ein ProceduralModel seinen Inhalt aufbaut.
-- Siehe https://create.roblox.com/docs/reference/engine/classes/ProceduralModel für Details.
--
-- Um als Generator verwendet zu werden, muss das ModuleScript eine Tabelle mit zwei Feldern zurückgeben:
--   * `Attributes`  - eine Tabelle mit Standardwerten. Jeder Schlüssel wird zu einem Attribut für jedes
--                     ProceduralModel, das diesen Generator verwendet. Benutzer können diese
--                     Attribute im Eigenschaftenfenster anpassen, um die Generierung mit neuen Eingaben
--                     erneut auszuführen.
--   * `OnGenerate`  - eine Funktion, die die Engine aufruft, um den Inhalt des Modells (neu) aufzubauen.
--
-- Nichts an diesem Skript oder seiner Platzierung ist besonders. Es kann überall im DataModel
-- leben und die `Generator`-Eigenschaft eines ProceduralModel kann neu zugewiesen werden, um darauf zu zeigen.

-- Die Typannotations sind optional, aber hier dokumentiert, damit die erforderliche Form explizit ist.

-- `GenerationFunctionParams` wird jedes Mal an `OnGenerate` übergeben, wenn die Generierung läuft. Es stellt bereit:
--   * `Attributes` - die aktuellen Attributwerte des ProceduralModel.
--   * `Size`       - das Begrenzungsvolumen, in dem erzeugt werden soll (von `ProceduralModel.Size`).
--   * `Pause`      - eine kooperative Pause. Rufen Sie `parameters:Pause()` innerhalb von langen Schleifen auf, damit große
--                    Generierungen den aufrufenden Thread nicht blockieren; die Engine kann Sie später fortsetzen.
type GenerationFunctionParams<Attributes> = {
	Attributes: Attributes,
	Size: Vector3,
	Pause: (self: GenerationFunctionParams<Attributes>) -> (),
}

-- `GeneratorModuleDefinition` ist die Tabelle, die das ModuleScript zurückgeben muss.
-- `OnGenerate` darf keinen Wert zurückgeben; erzeugte Instanzen in `targetContainer` einfügen.
-- Alles, was in `targetContainer` (oder seine Nachkommen) eingepflegt wird, wird zum Ergebnis der Generierung.
type GeneratorModuleDefinition<Attributes> = {
	Attributes: Attributes,
	OnGenerate: (
		parameters: GenerationFunctionParams<Attributes>,
		targetContainer: GeneratedFolder
	) -> (),
}

-- Standardattribute. Jeder Eintrag hier erscheint als ein bearbeitbares Attribut im ProceduralModel.
-- Ein festgelegter `RandomSeed` sorgt dafür, dass die Generierung deterministisch bleibt: die gleichen Eingaben
-- erzeugen immer die gleichen Ausgaben, was wichtig ist, da die Generierung möglicherweise viele Male ausgeführt wird, während der Benutzer Eigenschaften bearbeitet.
local defaultAttributes = {
	BorderThickness = 1,
	RandomSeed = 142376088,
}

local Generator: GeneratorModuleDefinition<typeof(defaultAttributes)> = {
	Attributes = defaultAttributes,
	OnGenerate = function(parameters, targetContainer)
		-- Eingaben. `parameters.Attributes` spiegelt wider, was der Benutzer auf dem
		-- ProceduralModel festgelegt hat; `parameters.Size` ist der Begrenzungsrahmen, in den aufgebaut werden soll.
		local borderThickness = parameters.Attributes.BorderThickness
		local random = Random.new(parameters.Attributes.RandomSeed)
		local size = parameters.Size

		-- Abgeleitete Werte. Seeded `random` oben macht diese reproduzierbar pro 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)

		-- Kleine Helfer, die die Konstruktion unten von oben nach unten lesbar machen. Sie sind nicht notwendig,
		-- um einen Generator zu schreiben; sie reduzieren lediglich die Wiederholung.
		local function assignProperties(instance: Instance, properties: { [string]: unknown })
			-- Setze Parent zuletzt, damit andere Eigenschaften vorhanden sind, bevor die Instanz
			-- in das DataModel eintritt und Änderungsereignisse ausgelöst werden.
			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 })
			-- Generierte Teile sind typischerweise verankert und nicht kollidierend; je nach Teil überschreiben.
			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

		-- Alles, was unten eingepflegt wird, geht in `targetContainer`, was bedeutet,
		-- dass Instanzen Teil des erzeugten Outputs werden. Instanzen, die hier nicht eingeordnet sind, werden verworfen.

		-- Unsichtbares Begrenzungsstück, das als Billboard-Adornee verwendet wird.
		local bounds = createPartWithDefaults({
			Name = "Bounds",
			Parent = targetContainer,
			Transparency = 1,
			Size = size,
		})

		-- Eine vertiefte Plattform mit einem Rand darunter.
		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),
		})

		-- "Hallo Welt!" Billboard. Generatoren können jeden Instanztyp erstellen, nicht nur Teile.
		local billboard = createInstance("BillboardGui", {
			Name = "Text",
			Parent = targetContainer,
			Adornee = bounds,
			LightInfluence = 0,
			Size = UDim2.fromScale(minSize, minSize),
		})
		local textLabel = createInstance("TextLabel", {
			Name = "HalloWelt",
			Parent = billboard,
			AnchorPoint = Vector2.new(0.5, 0.5),
			BackgroundTransparency = 1,
			Position = UDim2.fromScale(0.5, 0.5),
			Size = UDim2.fromScale(1, 1),
			Text = "Hallo Welt!",
			TextColor3 = baseColor,
			TextScaled = true,
			TextStrokeTransparency = 0,
		})
		local textStroke = createInstance("UIStroke", {
			Parent = textLabel,
			Color = outlineColor,
			Thickness = borderThickness * 3,
		})
	end,
}

-- Die Rückgabe der Moduldinition macht dieses ModuleScript als `Generator` verwendbar.
return Generator

-- Ein Generator-Modul ist ein ModuleScript, das eine Tabelle mit `Attributes` und `OnGenerate` zurückgibt.
-- Dieses ModuleScript der `Generator`-Eigenschaft eines ProceduralModels zuzuweisen,
-- führt `OnGenerate` aus, wann immer sich die Größe, Attribute oder der Modulinhalt des Modells ändert.
-- Siehe https://create.roblox.com/docs/reference/engine/classes/ProceduralModel.

local ClassicRobloxLadderGenerator = {}

-- Standardattributswerte. Jeder Schlüssel wird zu einem bearbeitbaren Attribut auf jedem ProceduralModel, das
-- diesen Generator verwendet, und erscheint im Studio-Eigenschaften-Panel unter Attribute. Das Bearbeiten eines
-- von ihnen führt `OnGenerate` mit den neuen Werten erneut aus.
ClassicRobloxLadderGenerator.Attributes = {
	RungSpacing = 2,
	RungThickness = 1,
	PostSize = 1,
	Color = Color3.new(0.5, 0.3, 0),
}

-- `OnGenerate` wird von der Engine aufgerufen, um den Inhalt des Modells zu erstellen.
-- Vertrag:
--   * `parameters.Size`       - der Umrandungsrahmen (von `ProceduralModel.Size`), in dem gebaut werden soll.
--   * `parameters.Attributes` - aktuelle Attributswerte des ProceduralModels.
--   * `parameters:Pause()`    - kooperative Abgabe; innerhalb langer Schleifen aufrufen,
--                               damit große Generierungen den Thread nicht blockieren.
--   * `targetContainer`       - alles, was hier (oder dessen Nachkommen) als Ausgabe fungiert.
--   * Geben Sie keinen Wert von `OnGenerate` zurück; Ausgaben werden über `targetContainer` kommuniziert.
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
		-- Das Einfügen in `targetContainer` fügt den Teil zur generierten Ausgabe hinzu.
		part.Parent = targetContainer
	end

	-- Sprossen, gestapelt vom unteren Ende des Umrandungsrahmens nach oben.
	local position = Vector3.new(0, -size.Y / 2 + rungThickness / 2, 0)
	for i = 1, count do
		-- Abgeben zwischen den Sprossen, damit eine Leiter mit vielen Sprossen den Thread nicht blockiert.
		parameters:Pause()
		createPart(position, Vector3.new(size.X - 2 * postSize, rungThickness, size.Z))
		position += Vector3.new(0, parameters.Attributes.RungSpacing, 0)
	end

	-- Linke und rechte Seitenpfosten, die die volle Höhe überspannen.
	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

-- Die Rückgabe der Moduldefinition macht dieses ModuleScript als einen `Generator` nutzbar.
return ClassicRobloxLadderGenerator

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