--[[
	SMART RNG V5.1 - ENGINE
	Dies ist LocalScript 1 von 2.

	Empfohlener Ort:
	StarterPlayer > StarterPlayerScripts

	Dieses Script:
	- liest PlayerData
	- erkennt Roll-, Upgrade-, Reset- und Rune-Buttons
	- bewertet wiederholbare und einmalige Upgrades gemeinsam
	- berücksichtigt, dass ungenutzte RP, SM, PP und Clovers selbst Wert besitzen
	- führt die beste gefundene Aktion aus
	- stellt eine Bindable-Schnittstelle für das zweite GUI-LocalScript bereit

	Kein Server-Hopping.
	Keine Robux-Käufe.
]]

if not game:IsLoaded() then
	game.Loaded:Wait()
end

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local LP = Players.LocalPlayer
local PlayerScripts = LP:WaitForChild("PlayerScripts")
local PlayerData = LP:WaitForChild("PlayerData")

--====================================================
-- BRIDGE ZUM GUI-SCRIPT
--====================================================

local function ensureChild(parent, className, name)
	local existing = parent:FindFirstChild(name)

	if existing and existing.ClassName ~= className then
		existing:Destroy()
		existing = nil
	end

	if not existing then
		existing = Instance.new(className)
		existing.Name = name
		existing.Parent = parent
	end

	return existing
end

local Bridge = PlayerScripts:FindFirstChild("_SmartRNGBridge")

if not Bridge then
	Bridge = Instance.new("Folder")
	Bridge.Name = "_SmartRNGBridge"
	Bridge.Parent = PlayerScripts
end

local CommandEvent =
	ensureChild(Bridge, "BindableEvent", "Command")

local StateChangedEvent =
	ensureChild(Bridge, "BindableEvent", "StateChanged")

local GetSnapshotFunction =
	ensureChild(Bridge, "BindableFunction", "GetSnapshot")

local EngineReadyValue =
	ensureChild(Bridge, "BoolValue", "EngineReady")

local EngineErrorValue =
	ensureChild(Bridge, "StringValue", "EngineError")

EngineReadyValue.Value = false
EngineErrorValue.Value = ""

--====================================================
-- ENGINE-STATE
--====================================================

local E = {
	Config = {
		Master = false,
		Strategy = "Balanced",

		AutoRoll = true,
		AutoRaritySpend = true,
		AutoRebirth = true,
		AutoRPUpgrades = true,
		AutoSuperMultiplier = true,
		AutoSMUpgrades = true,
		AutoPrestige = true,
		AutoPPUpgrades = true,
		AutoAscension = true,
		AutoCloverUpgrades = true,

		AutoCloverRunes = false,
		AutoPrestigeRunes = false,
		AutoMultiplierRunes = false,
		AutoPlantRunes = false,

		ButtonNoclip = true,
		AntiKnockback = true,

		-- Der ausgewählte Button wird kurz unter den Spieler gesetzt,
		-- aktiv gepulst und danach sicher neben dem Spieler geparkt.
		StageButtons = true,
		ReliableTouch = true,

		SpendBeforeReset = true,
		NormalRaritySpend = true,
	},

	State = {
		Ready = false,
		Busy = false,
		RollBusy = false,
		Dirty = true,

		LastAction = "Engine startet",
		Plan = "Warte auf Initialisierung",
		Error = nil,

		DecisionType = "Keine",
		DecisionScore = 0,
		TopDecisions = {},

		ButtonCount = 0,
		RepeatableCount = 0,
		GhostCount = 0,

		TouchMode = "Nicht geprüft",
		LastTouch = {},

		ActiveStagedPart = nil,
		StagedButtonName = "Keiner",
		TouchConfirmed = false,

		PreResetName = nil,
		PreResetSpends = 0,
	},

	Timing = {
		RollInterval = 0.10,
		ThinkInterval = 0.18,
		ActionSettle = 0.13,
		TouchCooldown = 0.10,
		NotifyInterval = 0.15,
	},

	Limits = {
		MaxPreResetSpends = 2,
		RarityReserveFraction = 0.68,
		NearMilestoneFraction = 0.15,
	},

	BankElasticity = {
		RebirthPoints = 0.55,
		UpgradesMultiMulti = 0.85,
		PrestigePoints = 0.50,
		Clovers = 0.32,
	},

	Stats = {},
	Bools = {},
	Buttons = {},
	ByCategory = {},
	ButtonConnections = {},
	GhostParts = {},
	GhostConnections = {},

	ButtonStageState = {},

	LastNotify = 0,
}

local OPTION_KEYS = {
	"AutoRoll",
	"AutoRaritySpend",
	"AutoRebirth",
	"AutoRPUpgrades",
	"AutoSuperMultiplier",
	"AutoSMUpgrades",
	"AutoPrestige",
	"AutoPPUpgrades",
	"AutoAscension",
	"AutoCloverUpgrades",
	"AutoCloverRunes",
	"AutoPrestigeRunes",
	"AutoMultiplierRunes",
	"AutoPlantRunes",
	"ButtonNoclip",
	"AntiKnockback",
	"StageButtons",
	"ReliableTouch",
}

--====================================================
-- BIG-NUMBER-NAMESPACE
--====================================================

local N = {}
N.NEG_INF = -math.huge
N.ZERO = {
	Log10 = N.NEG_INF,
	Number = 0,
	Raw = "0",
}

N.Suffix = {
	[""] = 0,
	K = 3,
	M = 6,
	B = 9,
	T = 12,

	Qd = 15,
	Qn = 18,
	Sx = 21,
	Sp = 24,
	Oc = 27,
	No = 30,

	De = 33,
	UDe = 36,
	DDe = 39,
	TDe = 42,
	QdDe = 45,
	QnDe = 48,
	SxDe = 51,
	SpDe = 54,
	OcDe = 57,
	NoDe = 60,

	Vg = 63,
	UVg = 66,
	DVg = 69,
	TVg = 72,
	QdVg = 75,
	QnVg = 78,
	SxVg = 81,
	SpVg = 84,
	OcVg = 87,
	NoVg = 90,

	Tg = 93,
	UTg = 96,
	DTg = 99,
	TTg = 102,
	QdTg = 105,
	QnTg = 108,
	SxTg = 111,
	SpTg = 114,
	OcTg = 117,
	NoTg = 120,

	qg = 123,
	Uqg = 126,
	Dqg = 129,
	Tqg = 132,
	Qdqg = 135,
	Qnqg = 138,
	Sxqg = 141,
	Spqg = 144,
	Ocqg = 147,
	Noqg = 150,

	Qg = 153,
	UQg = 156,
	DQg = 159,
	TQg = 162,
	QdQg = 165,
	QnQg = 168,
	SxQg = 171,
	SpQg = 174,
	OcQg = 177,
	NoQg = 180,

	sg = 183,
	Usg = 186,
	Dsg = 189,
	Tsg = 192,
	Qdsg = 195,
	Qnsg = 198,
	Sxsg = 201,
	Spsg = 204,
	Ocsg = 207,
	Nosg = 210,

	Sg = 213,
	USg = 216,
	DSg = 219,
	TSg = 222,
	QdSg = 225,
	QnSg = 228,
	SxSg = 231,
	SpSg = 234,
	OcSg = 237,
	NoSg = 240,

	Og = 243,
	UOg = 246,
	DOg = 249,
	TOg = 252,
	QdOg = 255,
	QnOg = 258,
	SxOg = 261,
	SpOg = 264,
	OcOg = 267,
	NoOg = 270,

	Ng = 273,
	UNg = 276,
	DNg = 279,
	TNg = 282,
	QdNg = 285,
	QnNg = 288,
	SxNg = 291,
	SpNg = 294,
	OcNg = 297,
	NoNg = 300,

	Ce = 303,
	UCe = 306,
	DCe = 309,
	TCe = 312,
	QdCe = 315,
	QnCe = 318,
	SxCe = 321,
	SpCe = 324,
	OcCe = 327,
	NoCe = 330,
}

function N.make(log10Value, number, raw)
	return {
		Log10 = log10Value,
		Number = number,
		Raw = raw,
	}
end

function N.fromNumber(value, raw)
	value = tonumber(value)

	if not value or value <= 0 then
		return N.ZERO
	end

	return N.make(
		math.log10(value),
		value,
		raw or tostring(value)
	)
end

function N.clean(text)
	text = tostring(text or "")
	text = text:gsub("<[^>]->", "")
	text = text:gsub(",", "")
	text = text:gsub("^%s+", "")
	text = text:gsub("%s+$", "")
	return text
end

function N.decode(value)
	value = tostring(value or "0;0")

	local layerText, magnitudeText =
		value:match(
			"^%s*([%-%d%.]+)%s*;%s*([%-%d%.eE+]+)%s*$"
		)

	if not layerText then
		return N.fromNumber(tonumber(value), value)
	end

	local layer = tonumber(layerText) or 0
	local magnitude = tonumber(magnitudeText) or 0

	if magnitude <= 0 then
		return N.ZERO
	end

	if layer <= 0 then
		return N.fromNumber(magnitude, value)
	end

	if layer == 1 then
		local number = nil

		if magnitude <= 308 then
			number = 10 ^ magnitude
		end

		return N.make(magnitude, number, value)
	end

	return N.make(
		layer * 1e12 + magnitude,
		nil,
		value
	)
end

function N.parseDisplay(text)
	text = N.clean(text)

	local scientific =
		text:match("([%d%.]+[eE][%+%-]?%d+)")

	if scientific then
		return N.fromNumber(
			tonumber(scientific),
			scientific
		)
	end

	local numberText, suffix =
		text:match(
			"([%d]+%.?[%d]*)%s*([%a]+)"
		)

	if not numberText then
		numberText =
			text:match("([%d]+%.?[%d]*)")

		suffix = ""
	end

	local number = tonumber(numberText)

	if not number then
		return N.ZERO
	end

	suffix = suffix or ""

	local exponent = N.Suffix[suffix] or 0
	local log10Value =
		math.log10(math.max(number, 1e-300))
		+ exponent

	local numeric = nil

	if log10Value <= 308 then
		numeric = number * 10 ^ exponent
	end

	return N.make(
		log10Value,
		numeric,
		numberText .. suffix
	)
end

function N.ge(a, b)
	return a.Log10 >= b.Log10 - 1e-10
end

function N.gt(a, b)
	return a.Log10 > b.Log10 + 1e-10
end

function N.add(a, b)
	if a.Log10 == N.NEG_INF then
		return b
	end

	if b.Log10 == N.NEG_INF then
		return a
	end

	local high = math.max(a.Log10, b.Log10)
	local low = math.min(a.Log10, b.Log10)

	local resultLog =
		high
		+ math.log10(
			1 + 10 ^ math.max(-300, low - high)
		)

	local number = nil

	if resultLog <= 308 then
		number = 10 ^ resultLog
	end

	return N.make(resultLog, number, "sum")
end

function N.scale(a, multiplier)
	multiplier = tonumber(multiplier) or 0

	if multiplier <= 0
		or a.Log10 == N.NEG_INF
	then
		return N.ZERO
	end

	return N.make(
		a.Log10 + math.log10(multiplier),
		a.Number and a.Number * multiplier or nil,
		"scaled"
	)
end

function N.ratioLog(a, b)
	if a.Log10 == N.NEG_INF then
		return N.NEG_INF
	end

	if b.Log10 == N.NEG_INF then
		return math.huge
	end

	return a.Log10 - b.Log10
end

function N.costFraction(cost, balance)
	if not cost
		or cost.Log10 == N.NEG_INF
		or balance.Log10 == N.NEG_INF
	then
		return 1
	end

	local difference =
		cost.Log10 - balance.Log10

	if difference >= 0 then
		return 1
	end

	if difference < -12 then
		return 0
	end

	return 10 ^ difference
end

function N.format(value)
	if not value
		or value.Log10 == N.NEG_INF
	then
		return "0"
	end

	if value.Number and value.Number < 1000 then
		if value.Number >= 100 then
			return string.format("%.0f", value.Number)
		elseif value.Number >= 10 then
			return string.format("%.1f", value.Number)
		else
			return string.format("%.2f", value.Number)
		end
	end

	local ordered = {}

	for suffix, exponent in pairs(N.Suffix) do
		table.insert(ordered, {
			Suffix = suffix,
			Exponent = exponent,
		})
	end

	table.sort(ordered, function(a, b)
		return a.Exponent < b.Exponent
	end)

	local selected = ordered[1]

	for _, entry in ipairs(ordered) do
		if entry.Exponent <= value.Log10 then
			selected = entry
		else
			break
		end
	end

	local displayed =
		10 ^ (value.Log10 - selected.Exponent)

	if displayed >= 100 then
		return string.format(
			"%.0f%s",
			displayed,
			selected.Suffix
		)
	elseif displayed >= 10 then
		return string.format(
			"%.1f%s",
			displayed,
			selected.Suffix
		)
	else
		return string.format(
			"%.2f%s",
			displayed,
			selected.Suffix
		)
	end
end

--====================================================
-- STATUS UND SNAPSHOT
--====================================================

function E.markDirty()
	E.State.Dirty = true
end

function E.notify(force)
	local now = os.clock()

	if not force
		and now - E.LastNotify
			< E.Timing.NotifyInterval
	then
		return
	end

	E.LastNotify = now
	StateChangedEvent:Fire()
end

function E.getStat(name)
	return E.Stats[name] or N.ZERO
end

function E.small(name)
	return E.getStat(name).Number or 0
end

function E.snapshot()
	local options = {}

	for _, key in ipairs(OPTION_KEYS) do
		options[key] = E.Config[key]
	end

	local decisions = {}

	for index, candidate in ipairs(
		E.State.TopDecisions
	) do
		if index > 5 then
			break
		end

		decisions[index] = {
			Name = candidate.Name,
			Type = candidate.Type,
			Score = candidate.Score,
			Details = candidate.Details,
		}
	end

	return {
		Ready = E.State.Ready,
		Master = E.Config.Master,
		Strategy = E.Config.Strategy,

		Options = options,

		LastAction = E.State.LastAction,
		Plan = E.State.Plan,
		Error = E.State.Error,

		DecisionType = E.State.DecisionType,
		DecisionScore = E.State.DecisionScore,
		Decisions = decisions,

		ButtonCount = E.State.ButtonCount,
		RepeatableCount =
			E.State.RepeatableCount,
		GhostCount = E.State.GhostCount,
		TouchMode = E.State.TouchMode,
		StagedButton = E.State.StagedButtonName,
		TouchConfirmed = E.State.TouchConfirmed,

		Stats = {
			Rarity = N.format(
				E.getStat("Rarity")
			),
			BestRarity = N.format(
				E.getStat("BestRarity")
			),
			Luck = N.format(
				E.getStat("LuckMulti")
			),
			Multiplier = N.format(
				E.getStat("MultiOriginal")
			),
			RP = N.format(
				E.getStat("RebirthPoints")
			),
			RPM = N.format(
				E.getStat("RPM")
			),
			SM = N.format(
				E.getStat("UpgradesMultiMulti")
			),
			PP = N.format(
				E.getStat("PrestigePoints")
			),
			Clovers = N.format(
				E.getStat("Clovers")
			),
			Ascension = N.format(
				E.getStat("Ascension")
			),
		},
	}
end

GetSnapshotFunction.OnInvoke = function()
	return E.snapshot()
end

--====================================================
-- PLAYERDATA-CACHE
--====================================================

local TRACKED_STATS = {
	"Rarity",
	"BestRarity",
	"LuckMulti",
	"RebirthPoints",
	"RPM",
	"MultiOriginal",
	"Lesschancelower",
	"UpgradesCashMulti",
	"UpgradesMultiMulti",
	"PrestigePoints",
	"PPM",
	"PrTime",
	"PRPM",
	"PSM",
	"Clovers",
	"CM",
	"CLM",
	"CRPM",
	"CLSM",
	"CLPP",
	"Ascension",
	"RuneBulk",
}

local TRACKED_BOOLS = {
	"IsRollin",
	"ToggleAutoRoll",
	"Upgrade1Used",
	"Upgrade2Used",
	"Upgrade3Used",
	"Upgrade4Used",
}

function E.refreshStat(name)
	local object = PlayerData:FindFirstChild(name)

	if not object then
		E.Stats[name] = N.ZERO
		return
	end

	if object:IsA("StringValue") then
		E.Stats[name] = N.decode(object.Value)
	elseif object:IsA("NumberValue")
		or object:IsA("IntValue")
	then
		E.Stats[name] =
			N.fromNumber(object.Value)
	else
		E.Stats[name] = N.ZERO
	end
end

function E.refreshBool(name)
	local object = PlayerData:FindFirstChild(name)

	E.Bools[name] =
		object
		and object:IsA("BoolValue")
		and object.Value
		or false
end

function E.watchStats()
	for _, name in ipairs(TRACKED_STATS) do
		E.refreshStat(name)

		local object =
			PlayerData:FindFirstChild(name)

		if object then
			object.Changed:Connect(function()
				E.refreshStat(name)
				E.markDirty()
			end)
		end
	end

	for _, name in ipairs(TRACKED_BOOLS) do
		E.refreshBool(name)

		local object =
			PlayerData:FindFirstChild(name)

		if object then
			object.Changed:Connect(function()
				E.refreshBool(name)
				E.markDirty()
			end)
		end
	end
end

--====================================================
-- BUTTON-ERKENNUNG
--====================================================

local ROOT_NAMES = {
	"Buttons",
	"Roll System",
	"asecnd",
	"runez",
	"runezz",
	"runezzz",
	"runeth",
}

function E.readString(parent, name)
	local object =
		parent and parent:FindFirstChild(name)

	if object and object:IsA("StringValue") then
		return object.Value, object
	end

	return nil, nil
end

function E.label(part, childName)
	local child = part:FindFirstChild(childName)

	return child
		and child:FindFirstChildWhichIsA(
			"TextLabel",
			true
		)
		or nil
end

function E.labelText(label)
	return label and N.clean(label.Text) or ""
end

function E.isTouchPart(instance)
	return instance:IsA("BasePart")
		and instance:FindFirstChildOfClass(
			"TouchTransmitter"
		) ~= nil
end

function E.categorize(meta)
	if meta.Path
		== "Workspace.Roll System.RollRarity"
	then
		return "Roll"
	end

	if meta.Path
		== "Workspace.asecnd.RollRarity"
	then
		return "Ascension"
	end

	if meta.Path
		== "Workspace.runez.RollRarity"
	then
		return "CloverRune"
	end

	if meta.Path
		== "Workspace.runezz.RollRarity"
	then
		return "PrestigeRune"
	end

	if meta.Path
		== "Workspace.runezzz.RollRarity"
	then
		return "MultiplierRune"
	end

	if meta.Path
		== "Workspace.runeth.RollRarity"
	then
		return "PlantRune"
	end

	if meta.Name == "Rebirth Get" then
		return "Rebirth"
	end

	if meta.Name == "Prestige Get" then
		return "Prestige"
	end

	if meta.Name == "Super Multi Get" then
		return "SuperReset"
	end

	if meta.CostStat == "Rarity"
		and meta.GiveStat == "MultiOriginal"
	then
		return "RarityMultiplier"
	end

	if meta.CostStat == "RebirthPoints" then
		return "RPUpgrade"
	end

	if meta.CostStat == "PrestigePoints" then
		return "PPUpgrade"
	end

	if meta.CostStat
		== "UpgradesMultiMulti"
	then
		return "SMUpgrade"
	end

	if meta.CostStat == "Clovers" then
		return "CloverUpgrade"
	end

	return "Other"
end

function E.isBought(meta)
	return string.find(
		string.lower(E.labelText(meta.Up2)),
		"bought",
		1,
		true
	) ~= nil
end

function E.determineRepeatable(meta)
	if E.isBought(meta) then
		return false
	end

	local up1 =
		string.lower(E.labelText(meta.Up1))

	if meta.Category == "RPUpgrade" then
		if meta.GiveStat == "RPM" then
			return true
		end

		if meta.GiveStat == "LuckMulti"
			and string.find(
				up1,
				"x luck",
				1,
				true
			)
			and not string.find(
				up1,
				"every rebirth",
				1,
				true
			)
			and not string.find(
				up1,
				"multiplier buttons",
				1,
				true
			)
		then
			return true
		end
	end

	if meta.Category == "SMUpgrade"
		or meta.Category == "PPUpgrade"
		or meta.Category == "CloverUpgrade"
	then
		return true
	end

	return false
end

function E.unregisterButton(part)
	local meta = E.Buttons[part]

	if not meta then
		return
	end

	E.Buttons[part] = nil

	local category =
		E.ByCategory[meta.Category]

	if category then
		for index = #category, 1, -1 do
			if category[index] == meta then
				table.remove(category, index)
				break
			end
		end
	end

	local connections =
		E.ButtonConnections[part]

	if connections then
		for _, connection in ipairs(
			connections
		) do
			connection:Disconnect()
		end
	end

	E.ButtonConnections[part] = nil
	E.recountButtons()
	E.markDirty()
end

function E.registerButton(part)
	if not E.isTouchPart(part)
		or E.Buttons[part]
	then
		return
	end

	local scriptFolder =
		part:FindFirstChild("Script")

	local costStat, costStatObject =
		E.readString(
			scriptFolder,
			"Whatstatcost"
		)

	local giveStat, giveStatObject =
		E.readString(
			scriptFolder,
			"Whatstatgives"
		)

	local baseCost, baseCostObject =
		E.readString(
			scriptFolder,
			"Cost"
		)

	local baseGive, baseGiveObject =
		E.readString(
			scriptFolder,
			"Gives"
		)

	local required, requiredObject =
		E.readString(
			scriptFolder,
			"Requiredrarity"
		)

	local formula, formulaObject =
		E.readString(
			scriptFolder,
			"Costformula"
		)

	if not formula then
		formula, formulaObject =
			E.readString(
				scriptFolder,
				"Costformulas"
			)
	end

	local meta = {
		Part = part,
		Path = part:GetFullName(),
		Name = part.Name,

		CostStat = costStat,
		GiveStat = giveStat,
		BaseCostRaw = baseCost,
		BaseGiveRaw = baseGive,
		RequiredRaw = required,
		CostFormula = formula,

		Up1 = E.label(part, "Up1"),
		Up2 = E.label(part, "Up2"),
		Up3 = E.label(part, "Up3"),

		ValueObjects = {
			costStatObject,
			giveStatObject,
			baseCostObject,
			baseGiveObject,
			requiredObject,
			formulaObject,
		},
	}

	meta.Category = E.categorize(meta)
	meta.Repeatable =
		E.determineRepeatable(meta)

	E.Buttons[part] = meta

	E.ByCategory[meta.Category] =
		E.ByCategory[meta.Category] or {}

	table.insert(
		E.ByCategory[meta.Category],
		meta
	)

	local connections = {}

	local function changed()
		meta.Repeatable =
			E.determineRepeatable(meta)

		E.recountButtons()
		E.markDirty()
	end

	for _, label in ipairs({
		meta.Up1,
		meta.Up2,
		meta.Up3,
	}) do
		if label then
			table.insert(
				connections,
				label:GetPropertyChangedSignal(
					"Text"
				):Connect(changed)
			)
		end
	end

	for _, object in ipairs(
		meta.ValueObjects
	) do
		if object then
			table.insert(
				connections,
				object.Changed:Connect(changed)
			)
		end
	end

	table.insert(
		connections,
		part.AncestryChanged:Connect(
			function()
				if not part:IsDescendantOf(
					workspace
				) then
					E.unregisterButton(part)
				end
			end
		)
	)

	E.ButtonConnections[part] = connections
	E.recountButtons()
	E.markDirty()
end

function E.recountButtons()
	local count = 0
	local repeatable = 0

	for _, meta in pairs(E.Buttons) do
		count += 1

		if meta.Repeatable then
			repeatable += 1
		end
	end

	E.State.ButtonCount = count
	E.State.RepeatableCount = repeatable
end

function E.scanButtons()
	for _, rootName in ipairs(ROOT_NAMES) do
		local root =
			workspace:FindFirstChild(rootName)

		if root then
			for _, descendant in ipairs(
				root:GetDescendants()
			) do
				if E.isTouchPart(descendant) then
					E.registerButton(descendant)
				end
			end
		end
	end

	E.recountButtons()
end

function E.category(name)
	return E.ByCategory[name] or {}
end

function E.single(name)
	for _, meta in ipairs(E.category(name)) do
		if meta.Part and meta.Part.Parent then
			return meta
		end
	end

	return nil
end

function E.currentCost(meta)
	if E.isBought(meta) then
		return nil
	end

	if meta.Category == "RPUpgrade"
		or meta.Category == "PPUpgrade"
		or meta.Category == "SMUpgrade"
		or meta.Category == "CloverUpgrade"
	then
		local displayed =
			N.parseDisplay(
				E.labelText(meta.Up2)
			)

		if displayed.Log10 ~= N.NEG_INF then
			return displayed
		end
	end

	if meta.BaseCostRaw then
		return N.decode(meta.BaseCostRaw)
	end

	return N.ZERO
end

function E.gain(meta)
	if meta.Category == "Rebirth"
		or meta.Category == "Prestige"
		or meta.Category == "SuperReset"
		or meta.Category == "Ascension"
	then
		return N.parseDisplay(
			E.labelText(meta.Up2)
		)
	end

	if meta.BaseGiveRaw then
		if string.sub(meta.BaseGiveRaw, 1, 1)
			== "*"
		then
			return N.fromNumber(
				tonumber(
					string.sub(
						meta.BaseGiveRaw,
						2
					)
				)
			)
		end

		return N.decode(meta.BaseGiveRaw)
	end

	return N.ZERO
end

function E.requiredRarity(meta)
	if meta.Category == "Ascension" then
		return 250
	end

	if not meta.RequiredRaw then
		return 0
	end

	return N.decode(meta.RequiredRaw).Number or 0
end

--====================================================
-- BUTTON-NOCLIP UND ANTI-KNOCKBACK
--====================================================

local GHOST_ROOTS = {
	Buttons = true,
	["Roll System"] = true,
	asecnd = true,
	runez = true,
	runezz = true,
	runezzz = true,
	runeth = true,
}

function E.insideGhostRoot(instance)
	local current = instance

	while current and current ~= workspace do
		if current.Parent == workspace
			and GHOST_ROOTS[current.Name]
		then
			return true
		end

		current = current.Parent
	end

	return false
end

function E.registerGhostPart(part)
	if E.GhostParts[part]
		or not part:IsA("BasePart")
		or not E.insideGhostRoot(part)
	then
		return
	end

	-- Nur Touch-Parts durchlässig lassen.
	if not part:FindFirstChildOfClass(
		"TouchTransmitter"
	) then
		return
	end

	E.GhostParts[part] = {
		Original = part.CanCollide,
	}

	local connections = {}

	table.insert(
		connections,
		part:GetPropertyChangedSignal(
			"CanCollide"
		):Connect(function()
			if E.Config.ButtonNoclip
				and part.Parent
				and part.CanCollide
			then
				part.CanCollide = false
			end
		end)
	)

	table.insert(
		connections,
		part.AncestryChanged:Connect(
			function()
				if not part:IsDescendantOf(
					workspace
				) then
					E.GhostParts[part] = nil
				end
			end
		)
	)

	E.GhostConnections[part] =
		connections

	if E.Config.ButtonNoclip then
		part.CanCollide = false
	end

	E.recountGhosts()
end

function E.recountGhosts()
	local count = 0

	for part in pairs(E.GhostParts) do
		if part and part.Parent then
			count += 1
		end
	end

	E.State.GhostCount = count
end

function E.applyGhostSetting()
	for part, data in pairs(E.GhostParts) do
		if part and part.Parent then
			part.CanCollide =
				E.Config.ButtonNoclip
				and false
				or data.Original
		end
	end
end

function E.scanGhosts()
	for rootName in pairs(GHOST_ROOTS) do
		local root =
			workspace:FindFirstChild(rootName)

		if root then
			for _, descendant in ipairs(
				root:GetDescendants()
			) do
				E.registerGhostPart(descendant)
			end
		end
	end

	E.recountGhosts()
end

RunService.Heartbeat:Connect(function()
	if not E.Config.AntiKnockback then
		return
	end

	local character = LP.Character
	local root = character
		and character:FindFirstChild(
			"HumanoidRootPart"
		)

	local humanoid = character
		and character:FindFirstChildOfClass(
			"Humanoid"
		)

	if not root
		or not humanoid
		or humanoid.Health <= 0
	then
		return
	end

	if humanoid.PlatformStand then
		humanoid.PlatformStand = false
	end

	local velocity =
		root.AssemblyLinearVelocity

	local horizontal = Vector3.new(
		velocity.X,
		0,
		velocity.Z
	)

	local maximumHorizontal =
		math.max(
			34,
			humanoid.WalkSpeed * 2.2
		)

	if horizontal.Magnitude
		> maximumHorizontal
	then
		local intended =
			humanoid.MoveDirection
			* humanoid.WalkSpeed

		root.AssemblyLinearVelocity =
			Vector3.new(
				intended.X,
				math.clamp(
					velocity.Y,
					-120,
					55
				),
				intended.Z
			)
	elseif velocity.Y > 55 then
		root.AssemblyLinearVelocity =
			Vector3.new(
				velocity.X,
				55,
				velocity.Z
			)
	end

	if root.AssemblyAngularVelocity.Magnitude
		> 18
	then
		root.AssemblyAngularVelocity =
			Vector3.zero
	end
end)

--====================================================
-- BUTTON-STAGING UND SICHERES PARKEN
--====================================================

function E.buttonRotation(part)
	return part.CFrame - part.Position
end

function E.rememberButtonStageState(part)
	local data = E.ButtonStageState[part]

	if data then
		return data
	end

	data = {
		OriginalCFrame = part.CFrame,
		OriginalCanCollide = part.CanCollide,
		OriginalCanTouch = part.CanTouch,
	}

	E.ButtonStageState[part] = data
	return data
end

function E.setButtonCFrame(part, targetCFrame)
	if not part or not part.Parent then
		return false
	end

	local success = pcall(function()
		part.AssemblyLinearVelocity = Vector3.zero
		part.AssemblyAngularVelocity = Vector3.zero
		part.CanCollide = false
		part.CanTouch = true
		part.CFrame = targetCFrame
	end)

	return success
end

function E.parkButton(part)
	if not part or not part.Parent then
		return
	end

	local root = E.rootPart()

	if not root then
		return
	end

	E.rememberButtonStageState(part)

	local sideDistance =
		root.Size.X * 0.5
		+ part.Size.X * 0.5
		+ 4

	local verticalOffset =
		-(root.Size.Y * 0.5 + part.Size.Y * 0.5)

	local parkingCFrame =
		root.CFrame
		* CFrame.new(
			sideDistance,
			verticalOffset,
			0
		)
		* E.buttonRotation(part)

	E.setButtonCFrame(part, parkingCFrame)

	if E.State.ActiveStagedPart == part then
		E.State.ActiveStagedPart = nil
	end

	E.State.StagedButtonName = "Keiner"
end

function E.parkActiveButton(exceptPart)
	local active = E.State.ActiveStagedPart

	if active and active ~= exceptPart then
		E.parkButton(active)
	end
end

function E.stageButton(part)
	if not E.Config.StageButtons
		or not part
		or not part.Parent
	then
		return false
	end

	local root = E.rootPart()

	if not root then
		return false
	end

	E.parkActiveButton(part)
	E.rememberButtonStageState(part)

	-- Der Button liegt leicht in den Füßen. Dadurch besteht kurz eine
	-- echte Überlappung, während firetouchinterest zusätzlich aktiv pulst.
	local verticalOffset =
		-(root.Size.Y * 0.5 + part.Size.Y * 0.5 - 0.35)

	local activeCFrame =
		root.CFrame
		* CFrame.new(0, verticalOffset, 0)
		* E.buttonRotation(part)

	local success = E.setButtonCFrame(
		part,
		activeCFrame
	)

	if success then
		E.State.ActiveStagedPart = part
		E.State.StagedButtonName = part.Name
	end

	return success
end

function E.restoreStagedButtons()
	E.parkActiveButton(nil)

	for part, data in pairs(E.ButtonStageState) do
		if part and part.Parent then
			pcall(function()
				part.CFrame = data.OriginalCFrame
				part.CanCollide = data.OriginalCanCollide
				part.CanTouch = data.OriginalCanTouch
			end)
		end
	end

	E.State.ActiveStagedPart = nil
	E.State.StagedButtonName = "Keiner"
end

function E.touchSources()
	local character = LP.Character

	if not character then
		return {}
	end

	local sources = {}
	local names = {
		"HumanoidRootPart",
		"LowerTorso",
		"UpperTorso",
		"Torso",
		"LeftFoot",
		"RightFoot",
		"Left Leg",
		"Right Leg",
	}

	local seen = {}

	for _, name in ipairs(names) do
		local part = character:FindFirstChild(name)

		if part
			and part:IsA("BasePart")
			and not seen[part]
		then
			seen[part] = true
			table.insert(sources, part)
		end
	end

	return sources
end

function E.buttonFingerprint(meta)
	if not meta then
		return tostring(E.Bools.IsRollin)
	end

	local values = {
		E.labelText(meta.Up1),
		E.labelText(meta.Up2),
		E.labelText(meta.Up3),
		tostring(E.Bools.IsRollin),
	}

	for _, statName in ipairs({
		meta.CostStat,
		meta.GiveStat,
		"Rarity",
		"RebirthPoints",
		"UpgradesMultiMulti",
		"PrestigePoints",
		"Clovers",
	}) do
		if statName then
			local object = PlayerData:FindFirstChild(statName)

			if object and object:IsA("ValueBase") then
				table.insert(values, tostring(object.Value))
			end
		end
	end

	return table.concat(values, "|")
end

function E.forceTouchPulse(source, buttonPart)
	-- Zuerst ein künstliches Touch-Ende senden. Das ist wichtig, wenn der
	-- Spieler oder Button schon länger still ineinander steht.
	E.FireTouch(source, buttonPart, 1)
	task.wait()
	E.FireTouch(source, buttonPart, 0)
	task.wait(0.025)
	E.FireTouch(source, buttonPart, 1)
end

--====================================================
-- TOUCH-AUSFÜHRUNG
--====================================================

function E.findGlobalFunction(names)
	local environments = {
		_G,
	}

	if type(getgenv) == "function" then
		local success, environment =
			pcall(getgenv)

		if success
			and type(environment) == "table"
		then
			table.insert(
				environments,
				environment
			)
		end
	end

	if type(getfenv) == "function" then
		local success, environment =
			pcall(getfenv)

		if success
			and type(environment) == "table"
		then
			table.insert(
				environments,
				environment
			)
		end
	end

	for _, environment in ipairs(
		environments
	) do
		for _, name in ipairs(names) do
			local value =
				rawget(environment, name)

			if type(value) == "function" then
				return value
			end
		end
	end

	return nil
end

E.FireTouch =
	E.findGlobalFunction({
		"firetouchinterest",
	})

function E.rootPart()
	local character = LP.Character

	return character
		and character:FindFirstChild(
			"HumanoidRootPart"
		)
end

function E.touch(part, meta)
	if not part or not part.Parent then
		return false
	end

	local root = E.rootPart()

	if not root then
		E.State.Error = "HumanoidRootPart fehlt"
		return false
	end

	if not E.FireTouch then
		E.State.TouchMode = "firetouchinterest fehlt"
		E.State.Error =
			"Die Ausführungsumgebung stellt "
			.. "firetouchinterest nicht bereit."

		EngineErrorValue.Value = E.State.Error
		return false
	end

	E.stageButton(part)
	task.wait(0.02)

	local before = E.buttonFingerprint(meta)
	local sources = E.touchSources()

	if #sources == 0 then
		E.State.Error = "Keine Character-Touchparts gefunden"
		E.parkButton(part)
		return false
	end

	local sent = false
	local confirmed = false
	local attempts = E.Config.ReliableTouch and 2 or 1

	for attempt = 1, attempts do
		local source = sources[
			math.min(attempt, #sources)
		]

		local success, result = pcall(function()
			E.forceTouchPulse(source, part)
		end)

		if success then
			sent = true
		else
			E.State.Error = tostring(result)
			EngineErrorValue.Value = E.State.Error
		end

		task.wait(0.07)

		local after = E.buttonFingerprint(meta)

		if after ~= before then
			confirmed = true
			break
		end
	end

	-- Nie einen alten Button im Spieler liegen lassen. Er wird nach jedem
	-- einzelnen Kauf oder Roll seitlich außerhalb der Hitbox geparkt.
	E.parkButton(part)

	E.State.TouchConfirmed = confirmed
	E.State.TouchMode = confirmed
		and "Puls-Touch bestätigt"
		or "Puls-Touch gesendet"

	return sent
end

function E.queue(meta, label)
	if E.State.Busy
		or not meta
		or not meta.Part
		or not meta.Part.Parent
	then
		return false
	end

	local now = os.clock()
	local previous =
		E.State.LastTouch[meta.Part] or 0

	if now - previous
		< E.Timing.TouchCooldown
	then
		return false
	end

	E.State.LastTouch[meta.Part] = now
	E.State.Busy = true
	E.State.LastAction = label
	E.notify(true)

	task.spawn(function()
		local success = E.touch(meta.Part, meta)

		if not success then
			E.State.LastAction =
				"Fehler: " .. label
		end

		task.wait(E.Timing.ActionSettle)

		E.State.Busy = false
		E.markDirty()
		E.notify(true)
	end)

	return true
end

function E.rollTouch()
	if E.State.RollBusy
		or E.Bools.IsRollin
	then
		return
	end

	local roll = E.single("Roll")

	if not roll then
		return
	end

	E.State.RollBusy = true

	task.spawn(function()
		E.touch(roll.Part, roll)
		task.wait(0.06)
		E.State.RollBusy = false
	end)
end

--====================================================
-- SMART-SCORING
--====================================================

E.Weight = {
	RPUpgrade = {
		RPM = 1.34,
		LuckMulti = 1.31,
		Lesschancelower = 1.22,
		UpgradesCashMulti = 1.14,
	},

	SMUpgrade = {
		LuckMulti = 1.34,
		MultiOriginal = 1.24,
		RPM = 1.22,
	},

	PPUpgrade = {
		PrTime = 1.32,
		PRPM = 1.29,
		PPM = 1.23,
		PSM = 1.20,
	},

	CloverUpgrade = {
		CLM = 1.34,
		CRPM = 1.30,
		CM = 1.25,
		CLSM = 1.17,
		CLPP = 1.13,
	},
}

E.CurrencyForCategory = {
	RPUpgrade = "RebirthPoints",
	SMUpgrade = "UpgradesMultiMulti",
	PPUpgrade = "PrestigePoints",
	CloverUpgrade = "Clovers",
}

function E.categoryEnabled(category)
	if category == "RPUpgrade" then
		return E.Config.AutoRPUpgrades
	elseif category == "SMUpgrade" then
		return E.Config.AutoSMUpgrades
	elseif category == "PPUpgrade" then
		return E.Config.AutoPPUpgrades
	elseif category == "CloverUpgrade" then
		return E.Config.AutoCloverUpgrades
	end

	return false
end

function E.baseWeight(meta)
	local category = E.Weight[meta.Category]
	local weight =
		category
		and category[meta.GiveStat]
		or 0.82

	if E.Config.Strategy == "FastestRarity" then
		if meta.GiveStat == "LuckMulti"
			or meta.GiveStat
				== "Lesschancelower"
			or meta.GiveStat == "CLM"
			or meta.GiveStat == "CM"
		then
			weight += 0.27
		else
			weight -= 0.03
		end
	elseif E.Config.Strategy == "ResetRush" then
		if meta.GiveStat == "RPM"
			or meta.GiveStat == "PRPM"
			or meta.GiveStat == "PSM"
			or meta.GiveStat == "CRPM"
			or meta.GiveStat
				== "UpgradesCashMulti"
		then
			weight += 0.28
		else
			weight -= 0.02
		end
	end

	return weight
end

function E.operationFactor(meta)
	if meta.BaseGiveRaw
		and string.sub(
			meta.BaseGiveRaw,
			1,
			1
		) == "*"
	then
		return math.max(
			1,
			tonumber(
				string.sub(
					meta.BaseGiveRaw,
					2
				)
			) or 1
		)
	end

	local gain = E.gain(meta)
	local current =
		E.getStat(meta.GiveStat or "")

	if gain.Log10 == N.NEG_INF then
		return 1.05
	end

	if current.Log10 == N.NEG_INF then
		return 2
	end

	local relativeLog =
		N.ratioLog(gain, current)

	if relativeLog > 6 then
		return 10
	end

	local relative =
		10 ^ math.max(-12, relativeLog)

	return math.max(1.01, 1 + relative)
end

function E.bankRetention(
	currencyName,
	cost,
	balance
)
	local elasticity =
		E.BankElasticity[currencyName]
		or 0

	if elasticity <= 0 then
		return 1
	end

	if not cost.Number or not balance.Number then
		local fraction =
			N.costFraction(cost, balance)

		return math.max(
			0.04,
			(1 - fraction) ^ elasticity
		)
	end

	if balance.Number <= 0 then
		return 1
	end

	local remaining =
		math.max(
			0,
			(balance.Number - cost.Number)
				/ balance.Number
		)

	return math.max(
		0.04,
		remaining ^ elasticity
	)
end

function E.upgradeCandidate(meta)
	if E.isBought(meta)
		or not E.categoryEnabled(
			meta.Category
		)
	then
		return nil
	end

	local currencyName =
		E.CurrencyForCategory[
			meta.Category
		]

	if not currencyName then
		return nil
	end

	local cost = E.currentCost(meta)

	if not cost
		or cost.Log10 == N.NEG_INF
	then
		return nil
	end

	local balance =
		E.getStat(currencyName)

	if not N.ge(balance, cost) then
		return nil
	end

	local directFactor =
		E.operationFactor(meta)

	local retention =
		E.bankRetention(
			currencyName,
			cost,
			balance
		)

	-- Das ist der zentrale Punkt:
	-- Ein RP-Kauf wird nicht nur anhand des Upgrades bewertet.
	-- Der Verlust der angesparten RP-Bank wird mit einberechnet,
	-- weil diese selbst weitere Multiplikationen beeinflusst.
	local effectiveFactor =
		directFactor * retention

	local score =
		E.baseWeight(meta) * 100

	score += math.log10(
		math.max(1e-6, effectiveFactor)
	) * 125

	score += math.max(
		0,
		N.ratioLog(balance, cost)
	) * 20

	score -=
		N.costFraction(cost, balance) * 85

	if meta.Repeatable then
		score += 32
	else
		-- Einmalige Meilenstein-Upgrades dürfen
		-- nicht von den zwei RP-Repeatables verdrängt werden.
		score += 230
	end

	if meta.Category == "RPUpgrade"
		and meta.Repeatable
	then
		if meta.GiveStat == "RPM" then
			score += 18
		elseif meta.GiveStat
			== "LuckMulti"
		then
			score += 15
		end
	end

	local name =
		E.labelText(meta.Up1)

	if name == "" then
		name = meta.Name
	end

	return {
		Meta = meta,
		Name = name,
		Type = meta.Category,
		Score = score,
		Cost = cost,
		Details = string.format(
			"Kosten %s | direkt x%.3f | "
				.. "Bank x%.3f | %s",
			N.format(cost),
			directFactor,
			retention,
			meta.Repeatable
				and "wiederholbar"
				or "einmalig"
		),
	}
end

function E.cheapestUnbought(
	category,
	currencyName
)
	local result = nil

	for _, meta in ipairs(
		E.category(category)
	) do
		if not E.isBought(meta) then
			local cost =
				E.currentCost(meta)

			if cost
				and cost.Log10
					~= N.NEG_INF
				and (
					not result
					or cost.Log10
						< result.Cost.Log10
				)
			then
				result = {
					Meta = meta,
					Cost = cost,
					Currency =
						E.getStat(
							currencyName
						),
				}
			end
		end
	end

	return result
end

function E.resetCandidate(
	meta,
	name,
	currencyName,
	upgradeCategory,
	baseScore,
	minimumFraction
)
	if not meta or not meta.Part.Parent then
		return nil
	end

	local gain = E.gain(meta)

	if gain.Log10 == N.NEG_INF then
		return nil
	end

	local current =
		E.getStat(currencyName)

	local after = N.add(current, gain)

	local nextUpgrade =
		E.cheapestUnbought(
			upgradeCategory,
			currencyName
		)

	local reachesUpgrade =
		nextUpgrade
		and N.ge(
			after,
			nextUpgrade.Cost
		)
		or false

	local fractionLog =
		N.ratioLog(gain, current)

	if not reachesUpgrade
		and current.Log10 ~= N.NEG_INF
		and fractionLog
			< math.log10(minimumFraction)
	then
		return nil
	end

	local score = baseScore

	if reachesUpgrade then
		score += 190
	end

	if fractionLog == math.huge then
		score += 160
	else
		score += math.max(
			-1,
			fractionLog
		) * 55
	end

	if E.Config.Strategy == "ResetRush" then
		score += 75
	elseif E.Config.Strategy
		== "FastestRarity"
	then
		score -= 20
	end

	return {
		Meta = meta,
		Name = name,
		Type = "Reset",
		Score = score,
		Gain = gain,
		Details = string.format(
			"Gewinn %s%s",
			N.format(gain),
			reachesUpgrade
				and " | erreicht nächstes Upgrade"
				or ""
		),
	}
end

function E.collectResetCandidates(list)
	local rarity = E.small("Rarity")

	if E.Config.AutoAscension
		and rarity >= 250
	then
		local meta = E.single("Ascension")

		if meta then
			table.insert(list, {
				Meta = meta,
				Name = "Ascension",
				Type = "Reset",
				Score = 1120,
				Gain = E.gain(meta),
				Details =
					"Höchste verfügbare Reset-Ebene",
			})
		end
	end

	if E.Config.AutoPrestige
		and rarity >= 99
	then
		local candidate =
			E.resetCandidate(
				E.single("Prestige"),
				"Prestige",
				"PrestigePoints",
				"PPUpgrade",
				820,
				0.60
			)

		if candidate then
			table.insert(list, candidate)
		end
	end

	if E.Config.AutoSuperMultiplier then
		local meta = E.single("SuperReset")

		if meta then
			local required =
				E.currentCost(meta)

			if required
				and N.ge(
					E.getStat(
						"MultiOriginal"
					),
					required
				)
			then
				local candidate =
					E.resetCandidate(
						meta,
						"Super Multiplier",
						"UpgradesMultiMulti",
						"SMUpgrade",
						650,
						0.45
					)

				if candidate then
					table.insert(
						list,
						candidate
					)
				end
			end
		end
	end

	if E.Config.AutoRebirth
		and rarity >= 5
	then
		local candidate =
			E.resetCandidate(
				E.single("Rebirth"),
				"Rebirth",
				"RebirthPoints",
				"RPUpgrade",
				430,
				0.30
			)

		if candidate then
			table.insert(list, candidate)
		end
	end
end

function E.nextRarityMilestone()
	local best = E.small("BestRarity")
	local nextValue = math.huge

	for _, meta in ipairs(
		E.category("RarityMultiplier")
	) do
		local required =
			E.requiredRarity(meta)

		if required > best
			and required < nextValue
		then
			nextValue = required
		end
	end

	if best < 99 then
		nextValue = math.min(nextValue, 99)
	end

	if best < 250 then
		nextValue = math.min(nextValue, 250)
	end

	if nextValue == math.huge then
		return nil
	end

	return nextValue
end

function E.raritySpendCandidate(reserve)
	if not E.Config.AutoRaritySpend then
		return nil
	end

	local current = E.small("Rarity")
	local best = E.small("BestRarity")
	local available = current - reserve

	if available <= 0 then
		return nil
	end

	local selected = nil

	for _, meta in ipairs(
		E.category("RarityMultiplier")
	) do
		local costObject =
			E.currentCost(meta)

		local cost =
			costObject and costObject.Number

		local required =
			E.requiredRarity(meta)

		if cost
			and cost > 0
			and cost <= available
			and best >= required
		then
			local gain = E.gain(meta)

			if gain.Log10 ~= N.NEG_INF then
				local efficiency =
					gain.Log10
					- math.log10(cost)

				-- Rarity-Spend bleibt absichtlich
				-- unter Reset- und guten Shop-Aktionen.
				local score =
					150 + efficiency * 55

				local name =
					E.labelText(meta.Up3)

				if name == "" then
					name = meta.Name
				end

				local candidate = {
					Meta = meta,
					Name = name,
					Type = "RaritySpend",
					Score = score,
					Details = string.format(
						"Rarity-Kosten %.3f | "
							.. "Multiplier %s",
						cost,
						N.format(gain)
					),
				}

				if not selected
					or candidate.Score
						> selected.Score
				then
					selected = candidate
				end
			end
		end
	end

	return selected
end

function E.normalRarityReserve()
	local current = E.small("Rarity")
	local best = E.small("BestRarity")
	local milestone =
		E.nextRarityMilestone()

	if milestone then
		local distance = milestone - best

		if distance > 0
			and distance
				<= math.max(
					1,
					best
						* E.Limits
							.NearMilestoneFraction
				)
		then
			return current
		end
	end

	return math.max(
		5,
		best
			* E.Limits.RarityReserveFraction
	)
end

function E.collectUpgradeCandidates(list)
	for category in pairs(
		E.CurrencyForCategory
	) do
		if E.categoryEnabled(category) then
			for _, meta in ipairs(
				E.category(category)
			) do
				local candidate =
					E.upgradeCandidate(meta)

				if candidate then
					table.insert(
						list,
						candidate
					)
				end
			end
		end
	end
end

function E.runeCandidate(
	enabled,
	category,
	name,
	currencyName,
	cost
)
	if not enabled then
		return nil
	end

	if not N.ge(
		E.getStat(currencyName),
		cost
	) then
		return nil
	end

	local meta = E.single(category)

	if not meta then
		return nil
	end

	return {
		Meta = meta,
		Name = name,
		Type = "Rune",
		Score = 35,
		Details =
			"Rune erst nach sicheren Upgrades",
	}
end

function E.collectRuneCandidates(list)
	local candidates = {
		E.runeCandidate(
			E.Config.AutoPrestigeRunes,
			"PrestigeRune",
			"Prestige-Rune",
			"PrestigePoints",
			N.fromNumber(10)
		),

		E.runeCandidate(
			E.Config.AutoCloverRunes,
			"CloverRune",
			"Clover-Rune",
			"Clovers",
			N.fromNumber(250)
		),

		E.runeCandidate(
			E.Config.AutoMultiplierRunes,
			"MultiplierRune",
			"Multiplier-Rune",
			"MultiOriginal",
			N.parseDisplay("1Ce")
		),

		E.runeCandidate(
			E.Config.AutoPlantRunes,
			"PlantRune",
			"Plant-Rune",
			"Clovers",
			N.parseDisplay("100K")
		),
	}

	for _, candidate in ipairs(candidates) do
		if candidate then
			table.insert(list, candidate)
		end
	end
end

function E.sortCandidates(list)
	table.sort(list, function(a, b)
		if a.Score == b.Score then
			return a.Name < b.Name
		end

		return a.Score > b.Score
	end)
end

function E.buildCandidates()
	local candidates = {}

	E.collectResetCandidates(candidates)
	E.collectUpgradeCandidates(candidates)

	if #candidates == 0
		and E.Config.NormalRaritySpend
	then
		local spend =
			E.raritySpendCandidate(
				E.normalRarityReserve()
			)

		if spend then
			table.insert(candidates, spend)
		end
	end

	if #candidates == 0 then
		E.collectRuneCandidates(candidates)
	end

	E.sortCandidates(candidates)
	E.State.TopDecisions = candidates

	return candidates
end

function E.executeReset(candidate)
	local reserve = 0

	if candidate.Name == "Rebirth" then
		reserve = 5
	elseif candidate.Name == "Prestige" then
		reserve = 99
	elseif candidate.Name == "Ascension" then
		reserve = 250
	end

	if E.Config.SpendBeforeReset
		and E.Config.AutoRaritySpend
	then
		if E.State.PreResetName
			~= candidate.Name
		then
			E.State.PreResetName =
				candidate.Name

			E.State.PreResetSpends = 0
		end

		if E.State.PreResetSpends
			< E.Limits.MaxPreResetSpends
		then
			local spend =
				E.raritySpendCandidate(
					reserve
				)

			if spend then
				E.State.PreResetSpends += 1

				E.State.Plan =
					"Vor "
					.. candidate.Name
					.. ": "
					.. spend.Name

				E.State.DecisionType =
					"Rarity vor Reset"

				E.State.DecisionScore =
					spend.Score

				return E.queue(
					spend.Meta,
					spend.Name
				)
			end
		end
	end

	E.State.PreResetName = nil
	E.State.PreResetSpends = 0

	E.State.Plan =
		candidate.Name
		.. " durchführen | "
		.. candidate.Details

	E.State.DecisionType = candidate.Type
	E.State.DecisionScore = candidate.Score

	return E.queue(
		candidate.Meta,
		candidate.Name
	)
end

function E.plannerStep()
	if not E.Config.Master
		or E.State.Busy
	then
		return
	end

	local candidates = E.buildCandidates()
	local best = candidates[1]

	if not best then
		E.State.Plan =
			"Rarity erhöhen und auf "
			.. "den nächsten sinnvollen Kauf sparen"

		E.State.DecisionType = "Warten"
		E.State.DecisionScore = 0
		E.notify()

		return
	end

	if best.Type == "Reset" then
		E.executeReset(best)
		return
	end

	E.State.PreResetName = nil
	E.State.PreResetSpends = 0

	E.State.Plan =
		best.Name
		.. " | "
		.. best.Details

	E.State.DecisionType = best.Type
	E.State.DecisionScore = best.Score

	E.queue(best.Meta, best.Name)
end

--====================================================
-- KOMMANDOS VOM GUI
--====================================================

function E.setOption(key, value)
	if E.Config[key] == nil then
		return
	end

	E.Config[key] = value == true

	if key == "ButtonNoclip" then
		E.applyGhostSetting()
	elseif key == "StageButtons"
		and not E.Config.StageButtons
	then
		E.restoreStagedButtons()
	end

	E.markDirty()
	E.notify(true)
end

function E.cycleStrategy()
	local strategies = {
		"Balanced",
		"FastestRarity",
		"ResetRush",
	}

	local current = 1

	for index, strategy in ipairs(
		strategies
	) do
		if strategy == E.Config.Strategy then
			current = index
			break
		end
	end

	current += 1

	if current > #strategies then
		current = 1
	end

	E.Config.Strategy =
		strategies[current]

	E.State.LastAction =
		"Strategie: "
		.. E.Config.Strategy

	E.markDirty()
	E.notify(true)
end

function E.printDebug()
	print("")
	print("========================================")
	print("SMART RNG V5 ENGINE DEBUG")
	print("========================================")
	print("Ready:", E.State.Ready)
	print("Master:", E.Config.Master)
	print("Strategie:", E.Config.Strategy)
	print("Touch:", E.State.TouchMode)
	print("Touch bestätigt:", E.State.TouchConfirmed)
	print("Geparkter/Aktiver Button:", E.State.StagedButtonName)
	print("Fehler:", E.State.Error or "keiner")
	print("Plan:", E.State.Plan)
	print("RP:", N.format(E.getStat("RebirthPoints")))
	print("RPM:", N.format(E.getStat("RPM")))
	print("Luck:", N.format(E.getStat("LuckMulti")))
	print("SM:", N.format(E.getStat("UpgradesMultiMulti")))
	print("PP:", N.format(E.getStat("PrestigePoints")))
	print("")
	print("Top-Entscheidungen:")

	for index, candidate in ipairs(
		E.State.TopDecisions
	) do
		if index > 8 then
			break
		end

		print(string.format(
			"%d. %s | %s | Score %.2f | %s",
			index,
			candidate.Name,
			candidate.Type,
			candidate.Score,
			candidate.Details
		))
	end

	print("========================================")
end

CommandEvent.Event:Connect(function(
	command,
	argument,
	value
)
	if command == "ToggleMaster" then
		E.Config.Master =
			not E.Config.Master

		E.State.LastAction =
			E.Config.Master
			and "Smart-Automatik gestartet"
			or "Smart-Automatik gestoppt"

		if not E.Config.Master then
			E.parkActiveButton(nil)
		end

		E.markDirty()
		E.notify(true)

	elseif command == "SetMaster" then
		E.Config.Master = argument == true

		if not E.Config.Master then
			E.parkActiveButton(nil)
		end

		E.markDirty()
		E.notify(true)

	elseif command == "ToggleOption" then
		local key = tostring(argument)

		if E.Config[key] ~= nil then
			E.setOption(
				key,
				not E.Config[key]
			)
		end

	elseif command == "SetOption" then
		E.setOption(
			tostring(argument),
			value
		)

	elseif command == "CycleStrategy" then
		E.cycleStrategy()

	elseif command == "Rescan" then
		E.scanButtons()
		E.scanGhosts()

		E.State.LastAction =
			"Buttons neu eingelesen"

		E.markDirty()
		E.notify(true)

	elseif command == "PrintDebug" then
		E.printDebug()
	end
end)

--====================================================
-- INITIALISIERUNG
--====================================================

local function initialize()
	E.watchStats()
	E.scanButtons()
	E.scanGhosts()
	E.applyGhostSetting()

	workspace.DescendantAdded:Connect(
		function(instance)
			if instance:IsA("BasePart")
				and E.insideGhostRoot(instance)
			then
				task.defer(function()
					E.registerGhostPart(instance)
				end)
			end

			if E.isTouchPart(instance) then
				task.defer(function()
					E.registerButton(instance)
				end)
			end
		end
	)

	E.State.Ready = true
	E.State.LastAction =
		"Engine bereit"

	E.State.Plan =
		"F10 oder GUI verwenden"

	EngineReadyValue.Value = true
	EngineErrorValue.Value = ""

	E.notify(true)
end

local success, result =
	xpcall(initialize, debug.traceback)

if not success then
	E.State.Error = tostring(result)
	E.State.LastAction =
		"Initialisierungsfehler"

	E.State.Plan =
		"GUI öffnen und F6-Debug ausführen"

	EngineErrorValue.Value =
		E.State.Error

	warn(
		"[SMART RNG V5.1 ENGINE FEHLER]",
		result
	)
end

--====================================================
-- LEICHTE LOOPS
--====================================================

task.spawn(function()
	while task.wait(E.Timing.RollInterval) do
		if E.Config.Master
			and E.Config.AutoRoll
			and not E.State.Busy
		then
			E.rollTouch()
		end
	end
end)

task.spawn(function()
	while task.wait(E.Timing.ThinkInterval) do
		if E.Config.Master
			and not E.State.Busy
		then
			local ok, err =
				pcall(function()
					E.plannerStep()
				end)

			if not ok then
				E.State.Error = tostring(err)
				E.State.LastAction =
					"Planerfehler"

				EngineErrorValue.Value =
					E.State.Error

				E.notify(true)
			end
		end
	end
end)

print("[SMART RNG V5.1 ENGINE] Geladen.")
print("[SMART RNG V5.1 ENGINE] Warte auf GUI-LocalScript.") 

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Next Script
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

--[[
	SMART RNG V5.1 - GUI
	Dies ist LocalScript 2 von 2.

	Empfohlener Ort:
	StarterPlayer > StarterPlayerScripts

	Das Engine-Script und dieses GUI-Script müssen beide laufen.
	Die Startreihenfolge ist egal. Das GUI wartet automatisch auf die Engine.

	F10        = Master-Automatik an/aus
	RightShift = GUI ein-/ausblenden
	F6         = Engine-Debug in die Konsole schreiben
]]

if not game:IsLoaded() then
	game.Loaded:Wait()
end

local Players = game:GetService("Players")
local UserInputService =
	game:GetService("UserInputService")

local LP = Players.LocalPlayer
local PlayerGui =
	LP:WaitForChild("PlayerGui")

local PlayerScripts =
	LP:WaitForChild("PlayerScripts")

--====================================================
-- GUI-STATE
--====================================================

local G = {
	Bridge = nil,
	Command = nil,
	StateChanged = nil,
	GetSnapshot = nil,
	ReadyValue = nil,
	ErrorValue = nil,

	Snapshot = nil,
	Connected = false,

	Gui = nil,
	Main = nil,
	MasterButton = nil,
	StrategyButton = nil,
	PlanLabel = nil,
	StatusLabel = nil,
	StatsLabel = nil,
	DecisionLabel = nil,
	EngineLabel = nil,

	ToggleButtons = {},
}

local COLORS = {
	Background = Color3.fromRGB(21, 22, 28),
	Panel = Color3.fromRGB(31, 33, 41),
	Panel2 = Color3.fromRGB(43, 46, 56),

	On = Color3.fromRGB(43, 139, 82),
	Off = Color3.fromRGB(132, 55, 61),
	Accent = Color3.fromRGB(65, 108, 205),

	Text = Color3.fromRGB(242, 242, 245),
	Muted = Color3.fromRGB(166, 170, 182),
	Plan = Color3.fromRGB(180, 208, 255),

	Error = Color3.fromRGB(255, 120, 120),
	Ready = Color3.fromRGB(115, 255, 155),
}

local TOGGLES = {
	{"AutoRoll", "Auto Roll"},
	{"AutoRaritySpend", "Rarity → Multiplier"},
	{"AutoRebirth", "Auto Rebirth"},
	{"AutoRPUpgrades", "RP-Upgrades"},
	{"AutoSuperMultiplier", "Super Multiplier"},
	{"AutoSMUpgrades", "SM-Upgrades"},
	{"AutoPrestige", "Auto Prestige"},
	{"AutoPPUpgrades", "PP-Upgrades"},
	{"AutoAscension", "Auto Ascension"},
	{"AutoCloverUpgrades", "Clover-Upgrades"},

	{"AutoCloverRunes", "Clover-Runes"},
	{"AutoPrestigeRunes", "Prestige-Runes"},
	{"AutoMultiplierRunes", "Multiplier-Runes"},
	{"AutoPlantRunes", "Plant-Runes"},

	{"ButtonNoclip", "Button-Noclip"},
	{"AntiKnockback", "Anti-Knockback"},
	{"StageButtons", "Button-Teleport"},
	{"ReliableTouch", "Touch-Puls"},
}

--====================================================
-- UI-HILFSFUNKTIONEN
--====================================================

local function addCorner(instance, radius)
	local corner = Instance.new("UICorner")
	corner.CornerRadius =
		UDim.new(0, radius or 8)
	corner.Parent = instance
end

local function makeLabel(
	parent,
	text,
	position,
	size,
	textSize
)
	local label = Instance.new("TextLabel")
	label.BackgroundTransparency = 1
	label.Position = position
	label.Size = size
	label.Font = Enum.Font.Gotham
	label.Text = text
	label.TextColor3 = COLORS.Text
	label.TextSize = textSize or 13
	label.TextWrapped = true
	label.TextXAlignment =
		Enum.TextXAlignment.Left
	label.TextYAlignment =
		Enum.TextYAlignment.Center
	label.Parent = parent

	return label
end

local function makeButton(
	parent,
	text,
	position,
	size
)
	local button = Instance.new("TextButton")
	button.Position = position
	button.Size = size
	button.BackgroundColor3 = COLORS.Panel2
	button.BorderSizePixel = 0
	button.AutoButtonColor = true
	button.Font = Enum.Font.GothamBold
	button.Text = text
	button.TextColor3 = COLORS.Text
	button.TextSize = 12
	button.Parent = parent

	addCorner(button, 7)

	return button
end

local function makeDraggable(frame, handle)
	local dragging = false
	local dragStart = nil
	local startPosition = nil

	handle.InputBegan:Connect(function(input)
		if input.UserInputType
			== Enum.UserInputType.MouseButton1
			or input.UserInputType
			== Enum.UserInputType.Touch
		then
			dragging = true
			dragStart = input.Position
			startPosition = frame.Position
		end
	end)

	UserInputService.InputChanged:Connect(
		function(input)
			if not dragging then
				return
			end

			if input.UserInputType
				== Enum.UserInputType.MouseMovement
				or input.UserInputType
				== Enum.UserInputType.Touch
			then
				local delta =
					input.Position - dragStart

				frame.Position = UDim2.new(
					startPosition.X.Scale,
					startPosition.X.Offset
						+ delta.X,
					startPosition.Y.Scale,
					startPosition.Y.Offset
						+ delta.Y
				)
			end
		end
	)

	UserInputService.InputEnded:Connect(
		function(input)
			if input.UserInputType
				== Enum.UserInputType.MouseButton1
				or input.UserInputType
				== Enum.UserInputType.Touch
			then
				dragging = false
			end
		end
	)
end

--====================================================
-- GUI ERSTELLEN
--====================================================

local function createGui()
	local old =
		PlayerGui:FindFirstChild(
			"_SmartRNGV5Gui"
		)

	if old then
		old:Destroy()
	end

	local screen = Instance.new("ScreenGui")
	screen.Name = "_SmartRNGV5Gui"
	screen.ResetOnSpawn = false
	screen.DisplayOrder = 1700
	screen.Parent = PlayerGui
	G.Gui = screen

	local main = Instance.new("Frame")
	main.Size = UDim2.fromOffset(570, 760)
	main.Position =
		UDim2.new(0, 18, 0.5, -380)
	main.BackgroundColor3 =
		COLORS.Background
	main.BorderSizePixel = 0
	main.Active = true
	main.Parent = screen
	G.Main = main

	addCorner(main, 11)

	local titleBar = Instance.new("Frame")
	titleBar.Size =
		UDim2.new(1, 0, 0, 44)
	titleBar.BackgroundColor3 =
		COLORS.Panel
	titleBar.BorderSizePixel = 0
	titleBar.Active = true
	titleBar.Parent = main

	addCorner(titleBar, 11)

	local title = makeLabel(
		titleBar,
		"Smart RNG V5.1",
		UDim2.fromOffset(14, 0),
		UDim2.new(1, -110, 1, 0),
		18
	)

	title.Font = Enum.Font.GothamBold

	local hide = makeButton(
		titleBar,
		"—",
		UDim2.new(1, -42, 0, 8),
		UDim2.fromOffset(32, 28)
	)

	hide.MouseButton1Click:Connect(function()
		screen.Enabled = false
	end)

	makeDraggable(main, titleBar)

	G.EngineLabel = makeLabel(
		main,
		"Warte auf Engine-LocalScript …",
		UDim2.fromOffset(14, 48),
		UDim2.new(1, -28, 0, 28),
		12
	)

	G.EngineLabel.TextColor3 = COLORS.Muted

	G.MasterButton = makeButton(
		main,
		"SMART AUTO: AUS",
		UDim2.fromOffset(12, 80),
		UDim2.new(0.58, -18, 0, 42)
	)

	G.MasterButton.BackgroundColor3 =
		COLORS.Off

	G.StrategyButton = makeButton(
		main,
		"Strategie: Balanced",
		UDim2.new(0.58, 0, 0, 80),
		UDim2.new(0.42, -12, 0, 42)
	)

	G.StrategyButton.BackgroundColor3 =
		COLORS.Accent

	G.PlanLabel = makeLabel(
		main,
		"Plan: Warte auf Engine",
		UDim2.fromOffset(14, 128),
		UDim2.new(1, -28, 0, 58),
		12
	)

	G.PlanLabel.TextColor3 = COLORS.Plan

	G.StatusLabel = makeLabel(
		main,
		"Aktion: keine",
		UDim2.fromOffset(14, 188),
		UDim2.new(1, -28, 0, 70),
		11
	)

	G.StatusLabel.TextColor3 =
		COLORS.Muted

	local statsPanel = Instance.new("Frame")
	statsPanel.Position =
		UDim2.fromOffset(12, 264)
	statsPanel.Size =
		UDim2.new(1, -24, 0, 126)
	statsPanel.BackgroundColor3 =
		COLORS.Panel
	statsPanel.BorderSizePixel = 0
	statsPanel.Parent = main

	addCorner(statsPanel, 8)

	G.StatsLabel = makeLabel(
		statsPanel,
		"Werte werden geladen …",
		UDim2.fromOffset(12, 8),
		UDim2.new(1, -24, 1, -16),
		12
	)

	G.StatsLabel.Font = Enum.Font.Code

	local decisionPanel = Instance.new("Frame")
	decisionPanel.Position =
		UDim2.fromOffset(12, 398)
	decisionPanel.Size =
		UDim2.new(1, -24, 0, 104)
	decisionPanel.BackgroundColor3 =
		COLORS.Panel
	decisionPanel.BorderSizePixel = 0
	decisionPanel.Parent = main

	addCorner(decisionPanel, 8)

	G.DecisionLabel = makeLabel(
		decisionPanel,
		"Top-Entscheidungen werden geladen …",
		UDim2.fromOffset(12, 6),
		UDim2.new(1, -24, 1, -12),
		11
	)

	G.DecisionLabel.Font = Enum.Font.Code

	local toolBar = Instance.new("Frame")
	toolBar.Position =
		UDim2.fromOffset(12, 510)
	toolBar.Size =
		UDim2.new(1, -24, 0, 34)
	toolBar.BackgroundTransparency = 1
	toolBar.Parent = main

	local toolLayout = Instance.new("UIListLayout")
	toolLayout.FillDirection =
		Enum.FillDirection.Horizontal
	toolLayout.Padding = UDim.new(0, 7)
	toolLayout.Parent = toolBar

	local rescanButton = makeButton(
		toolBar,
		"Buttons neu scannen",
		UDim2.new(),
		UDim2.new(0.5, -4, 1, 0)
	)

	local debugButton = makeButton(
		toolBar,
		"F6-Debug ausgeben",
		UDim2.new(),
		UDim2.new(0.5, -4, 1, 0)
	)

	local scroll =
		Instance.new("ScrollingFrame")

	scroll.Position =
		UDim2.fromOffset(12, 552)

	scroll.Size =
		UDim2.new(1, -24, 1, -564)

	scroll.BackgroundColor3 =
		COLORS.Panel

	scroll.BorderSizePixel = 0
	scroll.ScrollBarThickness = 7
	scroll.CanvasSize =
		UDim2.fromOffset(0, 0)
	scroll.Parent = main

	addCorner(scroll, 8)

	local padding = Instance.new("UIPadding")
	padding.PaddingTop = UDim.new(0, 8)
	padding.PaddingBottom = UDim.new(0, 8)
	padding.PaddingLeft = UDim.new(0, 8)
	padding.PaddingRight = UDim.new(0, 8)
	padding.Parent = scroll

	local layout = Instance.new("UIGridLayout")
	layout.CellSize =
		UDim2.new(0.5, -6, 0, 38)

	layout.CellPadding =
		UDim2.fromOffset(8, 8)

	layout.SortOrder =
		Enum.SortOrder.LayoutOrder

	layout.Parent = scroll

	for index, entry in ipairs(TOGGLES) do
		local key = entry[1]
		local displayName = entry[2]

		local button = makeButton(
			scroll,
			displayName,
			UDim2.new(),
			UDim2.new()
		)

		button.LayoutOrder = index

		button:SetAttribute(
			"OptionKey",
			key
		)

		button:SetAttribute(
			"DisplayName",
			displayName
		)

		G.ToggleButtons[key] = button

		button.MouseButton1Click:Connect(
			function()
				if G.Command then
					G.Command:Fire(
						"ToggleOption",
						key
					)
				end
			end
		)
	end

	layout:GetPropertyChangedSignal(
		"AbsoluteContentSize"
	):Connect(function()
		scroll.CanvasSize =
			UDim2.fromOffset(
				0,
				layout.AbsoluteContentSize.Y
					+ 16
			)
	end)

	G.MasterButton.MouseButton1Click:Connect(
		function()
			if G.Command then
				G.Command:Fire(
					"ToggleMaster"
				)
			end
		end
	)

	G.StrategyButton.MouseButton1Click:Connect(
		function()
			if G.Command then
				G.Command:Fire(
					"CycleStrategy"
				)
			end
		end
	)

	rescanButton.MouseButton1Click:Connect(
		function()
			if G.Command then
				G.Command:Fire("Rescan")
			end
		end
	)

	debugButton.MouseButton1Click:Connect(
		function()
			if G.Command then
				G.Command:Fire(
					"PrintDebug"
				)
			end
		end
	)
end

--====================================================
-- BRIDGE VERBINDEN
--====================================================

local function connectBridge()
	while not G.Connected do
		local bridge =
			PlayerScripts:FindFirstChild(
				"_SmartRNGBridge"
			)

		if bridge then
			local command =
				bridge:FindFirstChild(
					"Command"
				)

			local stateChanged =
				bridge:FindFirstChild(
					"StateChanged"
				)

			local getSnapshot =
				bridge:FindFirstChild(
					"GetSnapshot"
				)

			local ready =
				bridge:FindFirstChild(
					"EngineReady"
				)

			local errorValue =
				bridge:FindFirstChild(
					"EngineError"
				)

			if command
				and stateChanged
				and getSnapshot
				and ready
				and errorValue
			then
				G.Bridge = bridge
				G.Command = command
				G.StateChanged = stateChanged
				G.GetSnapshot = getSnapshot
				G.ReadyValue = ready
				G.ErrorValue = errorValue
				G.Connected = true

				stateChanged.Event:Connect(
					function()
						-- Der normale Refresh-Loop
						-- liest anschließend den Snapshot.
					end
				)

				return
			end
		end

		task.wait(0.25)
	end
end

local function requestSnapshot()
	if not G.GetSnapshot then
		return nil
	end

	local success, snapshot = pcall(function()
		return G.GetSnapshot:Invoke()
	end)

	if not success then
		return nil
	end

	return snapshot
end

--====================================================
-- GUI AKTUALISIEREN
--====================================================

local function updateToggleButtons(snapshot)
	local options = snapshot.Options or {}

	for key, button in pairs(
		G.ToggleButtons
	) do
		local enabled =
			options[key] == true

		local displayName =
			button:GetAttribute(
				"DisplayName"
			)

		button.Text =
			displayName
			.. (enabled and ": AN" or ": AUS")

		button.BackgroundColor3 =
			enabled
			and COLORS.On
			or COLORS.Off
	end
end

local function buildDecisionText(snapshot)
	local decisions = snapshot.Decisions or {}

	if #decisions == 0 then
		return "Keine kaufbare Aktion. "
			.. "Das Script spart oder rollt weiter."
	end

	local lines = {}

	for index, decision in ipairs(decisions) do
		if index > 3 then
			break
		end

		table.insert(
			lines,
			string.format(
				"%d. %s | %.1f\n   %s",
				index,
				tostring(decision.Name),
				tonumber(decision.Score) or 0,
				tostring(
					decision.Details or ""
				)
			)
		)
	end

	return table.concat(lines, "\n")
end

local function updateGui()
	if not G.Gui or not G.Gui.Enabled then
		return
	end

	if not G.Connected then
		G.EngineLabel.Text =
			"Warte auf Engine-LocalScript …"

		G.EngineLabel.TextColor3 =
			COLORS.Muted

		return
	end

	local snapshot = requestSnapshot()

	if not snapshot then
		G.EngineLabel.Text =
			"Engine verbunden, Snapshot fehlt"

		G.EngineLabel.TextColor3 =
			COLORS.Error

		return
	end

	G.Snapshot = snapshot

	if snapshot.Error
		and tostring(snapshot.Error) ~= ""
	then
		G.EngineLabel.Text =
			"Engine-Fehler: "
			.. tostring(snapshot.Error)

		G.EngineLabel.TextColor3 =
			COLORS.Error
	elseif snapshot.Ready then
		G.EngineLabel.Text =
			"Engine bereit | "
			.. tostring(snapshot.TouchMode)

		G.EngineLabel.TextColor3 =
			COLORS.Ready
	else
		G.EngineLabel.Text =
			"Engine initialisiert …"

		G.EngineLabel.TextColor3 =
			COLORS.Muted
	end

	G.MasterButton.Text =
		snapshot.Master
		and "SMART AUTO: AN"
		or "SMART AUTO: AUS"

	G.MasterButton.BackgroundColor3 =
		snapshot.Master
		and COLORS.On
		or COLORS.Off

	G.StrategyButton.Text =
		"Strategie: "
		.. tostring(snapshot.Strategy)

	G.PlanLabel.Text =
		"Plan: "
		.. tostring(snapshot.Plan)

	G.StatusLabel.Text = string.format(
		"Aktion: %s\n"
			.. "Entscheidung: %s | Score %.1f\n"
			.. "Buttons %d | Repeatables %d | Ghost %d | Aktiv %s",
		tostring(snapshot.LastAction),
		tostring(snapshot.DecisionType),
		tonumber(snapshot.DecisionScore)
			or 0,
		tonumber(snapshot.ButtonCount)
			or 0,
		tonumber(snapshot.RepeatableCount)
			or 0,
		tonumber(snapshot.GhostCount)
			or 0,
		tostring(snapshot.StagedButton or "Keiner")
	)

	local stats = snapshot.Stats or {}

	G.StatsLabel.Text = string.format(
		"Rarity: %s   Best: %s\n"
			.. "Luck: %s   Multiplier: %s\n"
			.. "RP: %s   RP-Multi: %s\n"
			.. "SM: %s   PP: %s\n"
			.. "Clovers: %s   Ascension: %s",
		tostring(stats.Rarity or "0"),
		tostring(stats.BestRarity or "0"),
		tostring(stats.Luck or "0"),
		tostring(stats.Multiplier or "0"),
		tostring(stats.RP or "0"),
		tostring(stats.RPM or "0"),
		tostring(stats.SM or "0"),
		tostring(stats.PP or "0"),
		tostring(stats.Clovers or "0"),
		tostring(stats.Ascension or "0")
	)

	G.DecisionLabel.Text =
		buildDecisionText(snapshot)

	updateToggleButtons(snapshot)
end

--====================================================
-- START
--====================================================

createGui()

task.spawn(function()
	connectBridge()
	updateGui()
end)

UserInputService.InputBegan:Connect(
	function(input, processed)
		if processed then
			return
		end

		if input.KeyCode == Enum.KeyCode.F10 then
			if G.Command then
				G.Command:Fire(
					"ToggleMaster"
				)
			end

		elseif input.KeyCode
			== Enum.KeyCode.RightShift
		then
			G.Gui.Enabled =
				not G.Gui.Enabled

			if G.Gui.Enabled then
				updateGui()
			end

		elseif input.KeyCode == Enum.KeyCode.F6 then
			if G.Command then
				G.Command:Fire(
					"PrintDebug"
				)
			end
		end
	end
)

task.spawn(function()
	while task.wait(0.30) do
		local success, result =
			pcall(updateGui)

		if not success then
			G.EngineLabel.Text =
				"GUI-Fehler: "
				.. tostring(result)

			G.EngineLabel.TextColor3 =
				COLORS.Error
		end
	end
end)

print("[SMART RNG V5.1 GUI] Geladen.")
print("[SMART RNG V5.1 GUI] Warte auf Engine.")