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

if getgenv()["DemonologyUI_Rayfield_XYNCZ"] then
	print("Previous gui detected!")
	game:GetService("StarterGui"):SetCore("SendNotification", {
		Title = "Previous gui detected!",
		Text = "Please close/destroy the previous gui first.",
		Duration = 5
	})
	return
end
getgenv()["DemonologyUI_Rayfield_XYNCZ"] = true

--------------------------------------------------------------
------------------------CORE VARIABLES------------------------
--------------------------------------------------------------
local RS = game:GetService("RunService")
local PS = game:GetService("Players")
local Lighting = game:GetService("Lighting")
local HttpService = game:GetService("HttpService")

local plr = PS.LocalPlayer

local CheckSpeedNum = 1
local LightToggleStatus = false
local IsEscapeHunt = false
local AutoSpiritBoxToggle = false
local PlayersEspToggle = false
local EvidenceEspToggle = false
local ItemEspToggle = false

local OldLightingList = {
	Ambient = Lighting.Ambient,
	OutdoorAmbient = Lighting.OutdoorAmbient,
	Brightness = Lighting.Brightness,
	GlobalShadows = Lighting.GlobalShadows,
	FogEnd = Lighting.FogEnd
}

local ItemEspList = {}
local EvidenceEspList = {}

local Func, Func2, FuncEvi

-- Dynamic Variables (Aman jika di-execute di Lobby)
local ghostModel = workspace:FindFirstChild("Ghost")
local roomsFolder = workspace:FindFirstChild("Map") and workspace.Map:FindFirstChild("Rooms")

task.spawn(function()
	while getgenv()["DemonologyUI_Rayfield_XYNCZ"] do
		task.wait(2)
		if not ghostModel then ghostModel = workspace:FindFirstChild("Ghost") end
		if not roomsFolder then
			local map = workspace:FindFirstChild("Map")
			if map then roomsFolder = map:FindFirstChild("Rooms") end
		end
	end
end)

--------------------------------------------------------------
------------------------CORE FUNCTIONS------------------------
--------------------------------------------------------------

function CheckInventory(ItemName)
	local Found = false
	local InvSlotNum = nil
	if not plr.PlayerGui:FindFirstChild("Hotbar") then return false, nil end
	
	for _, obj in ipairs(plr.PlayerGui.Hotbar.Slots:GetChildren()) do
		if obj:IsA("Frame") and string.find(string.lower(obj.Name), "invslot") then
			if obj:FindFirstChild("ItemName") and obj.ItemName.Text == ItemName then
				Found = true
				local str = obj.Name
				local num = tonumber(str:match("%d+"))
				InvSlotNum = num
			end
		end
	end
	return Found, InvSlotNum
end

function FindItem(ItemName)
	local Found = false
	local Model = nil
	local ItemFolder = workspace:FindFirstChild("Items")
	if not ItemFolder then return false, nil end
	
	for _, v in pairs(ItemFolder:GetChildren()) do
		if v:IsA("Model") and v:GetAttribute("ItemName") == ItemName then
			Found = true
			Model = v
		end
	end
	return Found, Model
end

function ActiveItem()
	local ItemModel = nil
	local Chara = plr.Character
	if Chara then
		for _, v in pairs(Chara:GetChildren()) do
			if v:IsA("Model") or tonumber(v.Name) then
				ItemModel = v
				if v:GetAttribute("Enabled") ~= true then
					local Handle = v:FindFirstChild("Handle")
					if Handle then
						game:GetService("ReplicatedStorage"):WaitForChild("Events"):WaitForChild("ToggleItemState"):FireServer(ItemModel)
						break
					end
				end
			end
		end
	end
	return true, ItemModel
end

function EquipItem(SlotNum)
	game:GetService("ReplicatedStorage"):WaitForChild("Events"):WaitForChild("RequestItemEquip"):FireServer("InvSlot" .. tostring(SlotNum))
	return true
end

function PickupItem(Model)
	game:GetService("ReplicatedStorage"):WaitForChild("Events"):WaitForChild("RequestItemPickup"):FireServer(Model)
	return true
end

function DropItem(SlotNum)
	game:GetService("ReplicatedStorage"):WaitForChild("Events"):WaitForChild("RequestItemDrop"):FireServer("InvSlot" .. tostring(SlotNum))
	return true
end

function GhostHuntingInfo()
	game:GetService("StarterGui"):SetCore("SendNotification", {Title = "Ghost hunting!", Text = "This action cannot be performed.", Duration = 3})
end

function CantTakePhotoInfo()
	game:GetService("StarterGui"):SetCore("SendNotification", {Title = "Cannot take a photo!", Text = "Nothing to take a photo of.", Duration = 3})
end

function AlreadyTakenGhostPhotoInfo()
	game:GetService("StarterGui"):SetCore("SendNotification", {Title = "-Info-", Text = "Ghost photo already taken!", Duration = 3})
end

function EquipPhotoCamera()
	local Found, InvSlotNum = CheckInventory("Photo Camera")
	if not Found then
		local Found2, Model = FindItem("Photo Camera")
		if Found2 and Model then
			PickupItem(Model)
			task.wait(0.5)
			local Found3, InvSlotNum2 = CheckInventory("Photo Camera")
			if Found3 then
				EquipItem(InvSlotNum2)
				task.wait(0.5)
				return true
			end
		end
	else
		EquipItem(InvSlotNum)
		task.wait(0.5)
		return true
	end
	return false
end

local function TpOutside()
	local success, err = pcall(function()
		local pegboard = workspace:WaitForChild("Map", 5)
		if pegboard then
			pegboard = pegboard:WaitForChild("Rooms", 5):WaitForChild("Base Camp", 5):WaitForChild("Pegboard", 5)
			local union = pegboard:FindFirstChild("Union")
			local char = plr.Character or plr.CharacterAdded:Wait()
			if union and char and char:FindFirstChild("HumanoidRootPart") then
				char.HumanoidRootPart.CFrame = union.CFrame + Vector3.new(0, 3, 0)
			end
		end
	end)
end

-- Auto escape hunt trigger
Func2 = workspace.DescendantAdded:Connect(function(descendant)
	if IsEscapeHunt and descendant:IsA("Sound") and descendant.Name == "Hunt" then
		TpOutside()
	end
end)

local function TpToGhost()
	local Chara = plr.Character
	if Chara and ghostModel then
		Chara:PivotTo(ghostModel:GetPivot())
	end
end

local function ToggleLightNow(Toggle)
	local Rooms = workspace:FindFirstChild("Map") and workspace.Map:FindFirstChild("Rooms")
	if not Rooms then return end
	for _, Room in pairs(Rooms:GetChildren()) do
		if Room:GetAttribute("LightsOn") ~= Toggle then
			game:GetService("ReplicatedStorage"):WaitForChild("Events"):WaitForChild("UseLightSwitch"):FireServer(Room)
		end
	end
end

local function ToggleAllDaLights()
	LightToggleStatus = not LightToggleStatus
	ToggleLightNow(LightToggleStatus)
end

local function FireSpiritBox()
	local args = {
		"Are you far away?", "Are you near?", "Where are you?", "What do you want?",
		"When did you cross over?", "Are you in the room with me?", "Do you want us to leave?",
		"When did you pass away?", "What is your goal?", "Why are you here?",
		"How long ago did you die?", "Is there a ghost here?"
	}
	game:GetService("ReplicatedStorage"):WaitForChild("Events"):WaitForChild("AskSpiritBoxFromUI"):FireServer(args[math.random(1, #args)])
end

local DelaySBTick = tick()
local function UseSpiritBox()
	if not AutoSpiritBoxToggle or not ghostModel then return end
	local Chara = plr.Character
	
	if ghostModel:GetAttribute("Hunting") ~= true then
		if Chara then Chara:PivotTo(ghostModel:GetPivot() * CFrame.new(0, 0, 10)) end
	else
		if Chara then TpOutside() end
	end

	if tick() - DelaySBTick > 0.5 and ghostModel:GetAttribute("Hunting") ~= true then
		DelaySBTick = tick()
		local Found, InvSlotNum = CheckInventory("Spirit Box")
		if not Found then
			local Found2, Model = FindItem("Spirit Box")
			if Found2 and Model then
				PickupItem(Model)
				task.wait(0.35)
				ActiveItem()
				task.wait(0.5)
				local Found3, InvSlotNum2 = CheckInventory("Spirit Box")
				if Found3 then
					EquipItem(InvSlotNum2)
					task.wait(0.5)
					FireSpiritBox()
				end
			end
		else
			EquipItem(InvSlotNum)
			task.wait(0.35)
			ActiveItem()
			task.wait(0.35)
			FireSpiritBox()
		end
	end
end

--------------------------------------------------------------
------------------------RAYFIELD UI SETUP---------------------
--------------------------------------------------------------
local Rayfield = loadstring(game:HttpGet('https://sirius.menu/rayfield'))()

local Window = Rayfield:CreateWindow({
   Name = "Demonology PRO | by XYNCZ",
   LoadingTitle = "Loading Demonology UI...",
   LoadingSubtitle = "by XYNCZ",
   ConfigurationSaving = {
      Enabled = true, 
      FolderName = "XYNCZ_Saves", 
      FileName = "XYNCZ_Config"
   },
   Discord = {
      Enabled = true,
      Invite = "mNTEpwnkZC", 
      RememberJoins = true 
   },
   KeySystem = false
})

--------------------------------------------------------------
------------------------TABS----------------------------------
--------------------------------------------------------------
local StatusTab = Window:CreateTab("Ghost Status", 4483362458)
local MainTab = Window:CreateTab("Main Hacks", 4483345998)
local VisualsTab = Window:CreateTab("ESP & Visuals", 4483362848)
local MiscTab = Window:CreateTab("Misc / Config", 4483345998)

--------------------------------------------------------------
------------------------STATUS TAB (INFO)---------------------
--------------------------------------------------------------
local GhostInfoPara = StatusTab:CreateParagraph({Title = "Ghost Info", Content = "Waiting for match to start..."})
local EvidencePara = StatusTab:CreateParagraph({Title = "Evidence Found", Content = "Waiting for data..."})
local PlayerEnergyPara = StatusTab:CreateParagraph({Title = "Player Energy", Content = "Waiting for data..."})

--------------------------------------------------------------
------------------------EVIDENCE DETECTION--------------------
--------------------------------------------------------------
local function TrackTemp()
	local Temp = 100
	local TempRoom = nil
	if not roomsFolder then return Temp, TempRoom end
	for _, room in ipairs(roomsFolder:GetChildren()) do
		if room:GetAttribute("Temperature") ~= nil then
			if room:GetAttribute("Temperature") < Temp then
				Temp = room:GetAttribute("Temperature")
				TempRoom = room
			end
		end
	end
	return Temp, TempRoom
end

local function CheckHandprints()
	local hpFolder = workspace:FindFirstChild("Handprints")
	if hpFolder then
		for _, obj in ipairs(hpFolder:GetDescendants()) do
			if obj:IsA("BasePart") then return true end
		end
	end
	for _, obj in ipairs(workspace:GetDescendants()) do
		if obj:IsA("BasePart") and (obj.Name == "Handprint1" or obj.Name == "Handprint2" or obj.Name == "Footprint" or obj.Name == "Footprint1") then
			return true
		end
	end
	return false
end

local function CheckGhostOrb()
	for _, obj in ipairs(workspace:GetDescendants()) do
		if obj:IsA("BasePart") and obj.Name == "GhostOrb" then return true end
	end
	return false
end

local function CheckEMF()
	local Level = 0
	for _, obj in ipairs(workspace:GetDescendants()) do
		if obj:IsA("Folder") and obj.Name == "Indicators" then
			for _, v in pairs(obj:GetChildren()) do
				if v:IsA("BasePart") and v.Material == Enum.Material.Neon and tonumber(v.Name) > Level then
					Level = tonumber(v.Name)
				end
			end
		end
	end
	return Level
end

local function CheckWither()
	local itemFolder = workspace:FindFirstChild("Items")
	if not itemFolder then return false end
	for _, obj in ipairs(itemFolder:GetDescendants()) do
		if obj:IsA("BasePart") and obj.Name == "Petals" and obj.Color == Color3.new(0,0,0) then
			return true
		end
	end
	return false
end

local function CheckGhostWriting()
	local itemFolder = workspace:FindFirstChild("Items")
	if not itemFolder then return false end
	for _, obj in ipairs(itemFolder:GetDescendants()) do
		if obj:IsA("Decal") then
			local Model = obj:FindFirstAncestorWhichIsA("Model")
			if Model and Model:GetAttribute("ItemName") == "Spirit Book" and obj.Texture ~= "" then
				return true
			end
		end
	end
	return false
end

local function CheckSpiritBox()
	local ui = plr:FindFirstChild("PlayerGui")
	if ui and ui:FindFirstChild("Subtitles") and ui.Subtitles:FindFirstChild("Holder") and ui.Subtitles.Holder:FindFirstChild("TextLabel") then
		local GhostText = ui.Subtitles.Holder.TextLabel.Text
		return #GhostText:gsub("%s+", "") >= 3
	end
	return false
end

--------------------------------------------------------------
------------------------HEARTBEAT LOOP------------------------
--------------------------------------------------------------
local LowestTemp = 100
local LowestTempRoom = nil
local HighestEMFLevel = 1
local OldTick = tick()

Func = RS.Heartbeat:Connect(function()
	UseSpiritBox()
	if tick() - OldTick > CheckSpeedNum then
		OldTick = tick()

		-- Get Evidences
		local Temp, TempRoom = TrackTemp()
		if Temp and TempRoom and Temp < LowestTemp then
			LowestTemp = Temp
			LowestTempRoom = TempRoom
		end
		
		local emfLvl = CheckEMF()
		if emfLvl > HighestEMFLevel then HighestEMFLevel = emfLvl end

		local ev_hp = CheckHandprints() and "Yes" or "No"
		local ev_orb = CheckGhostOrb() and "Yes" or "No"
		local ev_emf = tostring(HighestEMFLevel)
		local ev_wither = CheckWither() and "Yes" or "No"
		local ev_sb = CheckSpiritBox() and "Yes" or "No"
		local ev_write = CheckGhostWriting() and "Yes" or "No"
		
		local InLaser = ghostModel and ghostModel:GetAttribute("InLaser")
		local LaserVisible = ghostModel and ghostModel:GetAttribute("InLaser")
		local ev_laser = (InLaser and LaserVisible) and "Yes" or "No"

		local tempStr = string.format("%.1f°C", LowestTemp)
		if LowestTempRoom then tempStr = tempStr .. " ("..LowestTempRoom.Name..")" end

		EvidencePara:Set({
			Title = "Evidence Status",
			Content = string.format("Handprints: %s\nTemperature: %s\nGhost Orb: %s\nSpirit Box: %s\nEMF Level: %s\nGhost Writing: %s\nLaser Projector: %s\nWither: %s", 
				ev_hp, tempStr, ev_orb, ev_sb, ev_emf, ev_write, ev_laser, ev_wither)
		})

		-- Ghost Info
		if ghostModel then
			local isHunt = ghostModel:GetAttribute("Hunting")
			local favRoom = ghostModel:GetAttribute("FavoriteRoom") or "..."
			local curRoom = ghostModel:GetAttribute("CurrentRoom") or "..."
			local age = ghostModel:GetAttribute("Age") or "?"
			local gender = ghostModel:GetAttribute("Gender") or "?"
			local diff = workspace:GetAttribute("Difficulty") or "Unknown"

			GhostInfoPara:Set({
				Title = "Ghost Information - " .. (isHunt and "[HUNTING]" or "[CHILLING]"),
				Content = string.format("Difficulty: %s\nGender: %s | Age: %s\nFavorite Room: %s\nCurrent Room: %s", diff, gender, age, favRoom, curRoom)
			})
		else
			GhostInfoPara:Set({
				Title = "Ghost Information",
				Content = "Waiting for Match/Ghost to Spawn..."
			})
		end

		-- Player Energy
		local pText = ""
		for _, p in pairs(PS:GetPlayers()) do
			if p:GetAttribute("Energy") ~= nil then
				local e = math.floor(p:GetAttribute("Energy"))
				local name = p.Name == p.DisplayName and p.Name or p.Name.." ("..p.DisplayName..")"
				pText = pText .. name .. ": " .. e .. "%\n"
			end
		end
		PlayerEnergyPara:Set({Title = "Player Energy", Content = pText ~= "" and pText or "No data."})
	end
end)

--------------------------------------------------------------
------------------------MAIN TAB------------------------------
--------------------------------------------------------------
MainTab:CreateToggle({
	Name = "Hunt Escape (Auto TP Base)",
	CurrentValue = false,
	Flag = "AutoEscape",
	Callback = function(Value)
		IsEscapeHunt = Value
		if Value and ghostModel and ghostModel:GetAttribute("Hunting") then
			TpOutside()
		end
	end,
})

MainTab:CreateToggle({
	Name = "Auto Spirit Box",
	CurrentValue = false,
	Flag = "AutoSB",
	Callback = function(Value)
		AutoSpiritBoxToggle = Value
		if not Value then TpOutside() end
	end,
})

local db = false
MainTab:CreateButton({
	Name = "Place Stuffs Near Ghost",
	Callback = function()
		if not ghostModel then return end
		if ghostModel:GetAttribute("Hunting") == true or db == true then
			GhostHuntingInfo()
			return
		end
		db = true
		TpToGhost()
		
		task.wait(0.1); EquipItem(1); task.wait(0.1); DropItem(1); task.wait(0.1)
		EquipItem(1); task.wait(0.1); DropItem(1); task.wait(0.1)
		EquipItem(1); task.wait(0.1); DropItem(1); task.wait(0.2)

		local Found, Model = FindItem("Cross")
		if Found then PickupItem(Model) end
		task.wait(0.35)
		Found, Model = FindItem("Cross")
		if Found then PickupItem(Model) end
		task.wait(0.35)
		Found, Model = FindItem("Flower Pot")
		if Found then PickupItem(Model) end

		task.wait(0.5)

		EquipItem(1); task.wait(0.35); ActiveItem(); task.wait(0.35); DropItem(1); task.wait(0.35)
		EquipItem(1); task.wait(0.35); ActiveItem(); task.wait(0.35); DropItem(1); task.wait(0.35)
		EquipItem(1); task.wait(0.35); ActiveItem(); task.wait(0.35); DropItem(1); task.wait(0.5)

		Found, Model = FindItem("Laser Projector")
		if Found then PickupItem(Model) end
		task.wait(0.35)
		Found, Model = FindItem("EMF Reader")
		if Found then PickupItem(Model) end
		task.wait(0.35)
		Found, Model = FindItem("Spirit Book")
		if Found then PickupItem(Model) end

		task.wait(0.5)

		EquipItem(1); task.wait(0.6); ActiveItem(); task.wait(0.5); DropItem(1); task.wait(0.35)
		EquipItem(1); task.wait(0.6); ActiveItem(); task.wait(0.5); DropItem(1); task.wait(0.35)
		EquipItem(1); task.wait(0.35); ActiveItem(); task.wait(0.35); DropItem(1); task.wait(0.35)
		
		TpOutside()
		db = false
	end,
})

local db2 = false
MainTab:CreateButton({
	Name = "Take a Photo (Ghost)",
	Callback = function()
		if EquipPhotoCamera() and ghostModel then
			if db2 == false then
				db2 = true
				local args = {
					workspace.CurrentCamera.CFrame,
					{Stars = 3, Type = "Ghost", Object = ghostModel, Reward = 24}
				}
				game:GetService("ReplicatedStorage"):WaitForChild("Events"):WaitForChild("TakePhotoWithCamera"):FireServer(unpack(args))
			else
				AlreadyTakenGhostPhotoInfo()
			end
		end
	end,
})

local db3 = false
local function AlreadyTakenCheck(Obj) return Obj:GetAttribute("XYNCZAlreadyTakenPhoto") == true end

MainTab:CreateButton({
	Name = "Take 3 Stars Photo (Random)",
	Callback = function()
		if ghostModel and ghostModel:GetAttribute("Hunting") == true then GhostHuntingInfo() return end
		
		if db3 == false and EquipPhotoCamera() then
			db3 = true
			local Item = nil
			local ItemType = nil
			
			local itemsFolder = workspace:FindFirstChild("Items")
			if itemsFolder then
				for _, v in pairs(itemsFolder:GetChildren()) do
					if v:GetAttribute("DisplayName") == "Burnt Cross" and not AlreadyTakenCheck(v) then
						v:SetAttribute("XYNCZAlreadyTakenPhoto", true)
						Item = v; ItemType = "BurntCross"
						plr.Character.HumanoidRootPart.CFrame = v:GetPivot() * CFrame.new(0, 1, 0)
						break
					end
				end
			end

			if not ItemType then
				local interactables = workspace:FindFirstChild("Interactables")
				if interactables then
					for _, v in pairs(interactables:GetChildren()) do
						if v:GetAttribute("PhotoRewardAvailable") == true and not AlreadyTakenCheck(v) then
							v:SetAttribute("XYNCZAlreadyTakenPhoto", true)
							Item = v; ItemType = "Interaction"
							plr.Character.HumanoidRootPart.CFrame = v:GetPivot() * CFrame.new(0, 1, 0)
							break
						end
					end
				end
			end

			if ItemType and Item then
				local rw = ItemType == "BurntCross" and 12 or 8
				local args = {
					workspace.CurrentCamera.CFrame,
					{Stars = 3, Type = ItemType, Object = Item, Reward = rw}
				}
				game:GetService("ReplicatedStorage"):WaitForChild("Events"):WaitForChild("TakePhotoWithCamera"):FireServer(unpack(args))
			else
				CantTakePhotoInfo()
			end
			
			task.wait(1)
			TpOutside()
			task.wait(1)
			db3 = false
		end
	end,
})

MainTab:CreateButton({
	Name = "Turn On Fuse",
	Callback = function()
		game:GetService("ReplicatedStorage"):WaitForChild("Events"):WaitForChild("ToggleFuseBox"):FireServer()
	end,
})

MainTab:CreateButton({
	Name = "Toggle All Lights",
	Callback = ToggleAllDaLights,
})

--------------------------------------------------------------
------------------------VISUALS TAB---------------------------
--------------------------------------------------------------
local GhostBBGui, GhostHL
VisualsTab:CreateToggle({
	Name = "Ghost ESP",
	CurrentValue = false,
	Flag = "GhostESP",
	Callback = function(Value)
		if Value then
			if not GhostBBGui and ghostModel then
				GhostBBGui = Instance.new("BillboardGui")
				local TextLabel = Instance.new("TextLabel")
				GhostHL = Instance.new("Highlight")

				GhostBBGui.Parent = game:GetService("CoreGui")
				GhostBBGui.AlwaysOnTop = true
				GhostBBGui.Size = UDim2.new(0, 60, 0, 60)
				GhostBBGui.Adornee = ghostModel

				TextLabel.Parent = GhostBBGui
				TextLabel.BackgroundTransparency = 1
				TextLabel.Size = UDim2.new(1, 0, 1, 0)
				TextLabel.Text = "Ghost"
				TextLabel.TextColor3 = Color3.fromRGB(255, 0, 0)
				TextLabel.TextScaled = true

				GhostHL.Parent = game:GetService("CoreGui")
				GhostHL.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
				GhostHL.OutlineColor = Color3.fromRGB(255, 0, 0)
				GhostHL.FillTransparency = 1
				GhostHL.Adornee = ghostModel
			end
			if GhostBBGui then GhostBBGui.Enabled = true end
			if GhostHL then GhostHL.Enabled = true end
		else
			if GhostBBGui then GhostBBGui.Enabled = false end
			if GhostHL then GhostHL.Enabled = false end
		end
	end,
})

VisualsTab:CreateToggle({
	Name = "Item ESP",
	CurrentValue = false,
	Flag = "ItemESP",
	Callback = function(Value)
		ItemEspToggle = Value
		for _, v in pairs(ItemEspList) do
			if v then v:Destroy() end
		end
		ItemEspList = {}

		if Value then
			for _, v in pairs(workspace:GetDescendants()) do
				if v:IsA("Model") and v:GetAttribute("ItemName") ~= nil then
					local BillboardGui = Instance.new("BillboardGui")
					local TextLabel = Instance.new("TextLabel")
					local HL = Instance.new("Highlight")
					
					table.insert(ItemEspList, BillboardGui)
					table.insert(ItemEspList, HL)

					BillboardGui.Parent = game:GetService("CoreGui")
					BillboardGui.AlwaysOnTop = true
					BillboardGui.Size = UDim2.new(0, 100, 0, 40)
					BillboardGui.Adornee = v

					TextLabel.Parent = BillboardGui
					TextLabel.BackgroundTransparency = 1
					TextLabel.Size = UDim2.new(1, 0, 1, 0)
					TextLabel.Text = v:GetAttribute("ItemName")
					TextLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
					TextLabel.TextScaled = true

					HL.Parent = game:GetService("CoreGui")
					HL.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
					HL.OutlineColor = Color3.fromRGB(255, 170, 0)
					HL.FillTransparency = 1
					HL.Adornee = v
				end
			end
		end
	end,
})

local function UpdatePlrEsp()
	for _, p in pairs(game:GetService("Players"):GetPlayers()) do
		if p.Character then
			local root = p.Character:FindFirstChild("HumanoidRootPart")
			if root then
				local Esp1 = root:FindFirstChild("XYNCZPlrBil")
				local Esp2 = root:FindFirstChild("XYNCZPlrEsp")

				if PlayersEspToggle then
					if not Esp1 and not Esp2 then
						local BillboardGui = Instance.new("BillboardGui", root)
						BillboardGui.Name = "XYNCZPlrBil"
						BillboardGui.AlwaysOnTop = true
						BillboardGui.Size = UDim2.new(0, 100, 0, 40)
						BillboardGui.Adornee = root

						local TextLabel = Instance.new("TextLabel", BillboardGui)
						TextLabel.BackgroundTransparency = 1
						TextLabel.Size = UDim2.new(1, 0, 1, 0)
						TextLabel.TextColor3 = Color3.fromRGB(0, 170, 255)
						TextLabel.TextScaled = true
						TextLabel.Text = p.DisplayName

						local HL = Instance.new("Highlight", root)
						HL.Name = "XYNCZPlrEsp"
						HL.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
						HL.OutlineColor = Color3.fromRGB(0, 170, 255)
						HL.FillTransparency = 1
						HL.Adornee = p.Character
					end
				else
					if Esp1 then Esp1:Destroy() end
					if Esp2 then Esp2:Destroy() end
				end
			end
		end
	end
end

VisualsTab:CreateToggle({
	Name = "Players ESP",
	CurrentValue = false,
	Flag = "PlayersESP",
	Callback = function(Value)
		PlayersEspToggle = Value
		UpdatePlrEsp()
	end,
})

task.spawn(function()
	while getgenv()["DemonologyUI_Rayfield_XYNCZ"] do
		task.wait(1)
		if PlayersEspToggle then UpdatePlrEsp() end
	end
end)

local function UpdateEvidenceEsp()
	for _, v in pairs(EvidenceEspList) do
		if v then v:Destroy() end
	end
	EvidenceEspList = {}

	if EvidenceEspToggle then
		local hpFolder = workspace:FindFirstChild("Handprints")
		if hpFolder then
			for _, obj in ipairs(hpFolder:GetDescendants()) do
				if obj:IsA("BasePart") then
					local BillboardGui = Instance.new("BillboardGui")
					table.insert(EvidenceEspList, BillboardGui)

					BillboardGui.Parent = game:GetService("CoreGui")
					BillboardGui.AlwaysOnTop = true
					BillboardGui.Size = UDim2.new(1, 0, 1, 0)
					BillboardGui.Adornee = obj
					BillboardGui.StudsOffset = Vector3.new(0, 1, 0)

					local ImageLabelFromSG = nil
					for _, v in pairs(obj:GetDescendants()) do
						if v:IsA("ImageLabel") then ImageLabelFromSG = v:Clone() end
					end
					if ImageLabelFromSG ~= nil then
						ImageLabelFromSG.Parent = BillboardGui
						ImageLabelFromSG.BackgroundTransparency = 1
						ImageLabelFromSG.Size = UDim2.new(1, 0, 1, 0)
					end
				end
			end
		end

		local GhostOrbPart = nil
		for _, obj in ipairs(workspace:GetDescendants()) do
			if obj:IsA("BasePart") and obj.Name == "GhostOrb" then
				GhostOrbPart = obj; GhostOrbPart.Transparency = 0
				break
			end
		end

		if GhostOrbPart then
			local BillboardGui = Instance.new("BillboardGui")
			local TextLabel = Instance.new("TextLabel")
			local HL = Instance.new("Highlight")
			
			table.insert(EvidenceEspList, BillboardGui)
			table.insert(EvidenceEspList, HL)

			BillboardGui.Parent = game:GetService("CoreGui")
			BillboardGui.AlwaysOnTop = true
			BillboardGui.Size = UDim2.new(3, 0, 3, 0)
			BillboardGui.Adornee = GhostOrbPart

			TextLabel.Parent = BillboardGui
			TextLabel.BackgroundTransparency = 1
			TextLabel.Size = UDim2.new(1, 0, 1, 0)
			TextLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
			TextLabel.TextScaled = true
			TextLabel.Text = "Orb"

			HL.Parent = game:GetService("CoreGui")
			HL.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
			HL.OutlineColor = Color3.fromRGB(255, 255, 255)
			HL.FillTransparency = 1
			HL.Adornee = GhostOrbPart
		end
	end
end

VisualsTab:CreateToggle({
	Name = "Evidence ESP (Handprints, Orbs)",
	CurrentValue = false,
	Flag = "EvidenceESP",
	Callback = function(Value)
		EvidenceEspToggle = Value
		UpdateEvidenceEsp()
	end,
})

task.spawn(function()
	local Folder = workspace:WaitForChild("Handprints", 10)
	if Folder then
		FuncEvi = Folder.ChildAdded:Connect(function() 
			if getgenv()["DemonologyUI_Rayfield_XYNCZ"] then UpdateEvidenceEsp() end
		end)
	end
end)

VisualsTab:CreateToggle({
	Name = "Full Bright",
	CurrentValue = false,
	Flag = "FullBright",
	Callback = function(Value)
		if Value then
			Lighting.Ambient = Color3.new(1, 1, 1)
			Lighting.OutdoorAmbient = Color3.new(1, 1, 1)
			Lighting.Brightness = 3
			Lighting.GlobalShadows = false
			Lighting.FogEnd = 100000
		else
			Lighting.Ambient = OldLightingList.Ambient
			Lighting.OutdoorAmbient = OldLightingList.OutdoorAmbient
			Lighting.Brightness = OldLightingList.Brightness
			Lighting.GlobalShadows = OldLightingList.GlobalShadows
			Lighting.FogEnd = OldLightingList.FogEnd
		end
	end,
})

--------------------------------------------------------------
------------------------MISC TAB------------------------------
--------------------------------------------------------------
MiscTab:CreateSection("General Options")

MiscTab:CreateSlider({
	Name = "WalkSpeed",
	Range = {10, 100},
	Increment = 1,
	Suffix = "Speed",
	CurrentValue = 16,
	Flag = "WalkSpeedSlider",
	Callback = function(Value)
		if plr.Character and plr.Character:FindFirstChild("Humanoid") then
			plr.Character.Humanoid.WalkSpeed = Value
		end
	end,
})

MiscTab:CreateSlider({
	Name = "Update Status Delay (Seconds)",
	Range = {0.1, 5},
	Increment = 0.1,
	Suffix = "s",
	CurrentValue = 1,
	Flag = "UpdateDelay",
	Callback = function(Value)
		CheckSpeedNum = Value
	end,
})

MiscTab:CreateButton({
	Name = "Load Infinite Yield",
	Callback = function()
		loadstring(game:HttpGet('https://raw.githubusercontent.com/EdgeIY/infiniteyield/master/source'))()
	end,
})

MiscTab:CreateInput({
   Name = "Auto-Execute (Teleport) Link",
   PlaceholderText = "Paste your Script URL here...",
   RemoveTextAfterFocusLost = false,
   Callback = function(Text)
		if Text and Text ~= "" then
			local qot = queue_on_teleport or syn and syn.queue_on_teleport or fluxus and fluxus.queue_on_teleport
			if qot then
				qot('loadstring(game:HttpGet("'..Text..'"))()')
				Rayfield:Notify({
					Title = "Auto Load Active!", 
					Content = "Script will auto load when you teleport to the match.", 
					Duration = 5
				})
			else
				Rayfield:Notify({
					Title = "Executor Error", 
					Content = "Your executor does not support queue_on_teleport.", 
					Duration = 5
				})
			end
		end
   end,
})

--------------------------------------------------------------
------------------------CUSTOM CONFIG SYSTEM------------------
--------------------------------------------------------------
MiscTab:CreateSection("Custom Configuration")

local ConfigFolder = "XYNCZ_Configs"
if not isfolder(ConfigFolder) then makefolder(ConfigFolder) end

MiscTab:CreateInput({
	Name = "Config Name",
	PlaceholderText = "Type config name here (e.g. Farming)",
	RemoveTextAfterFocusLost = false,
	Callback = function(Text)
		 getgenv().XYNCZ_ConfigName = Text
	end,
})

MiscTab:CreateButton({
	Name = "Save Config",
	Callback = function()
		local name = getgenv().XYNCZ_ConfigName
		if not name or name == "" then name = "Default" end
		
		local config = {
			AutoEscape = Rayfield.Flags["AutoEscape"].CurrentValue,
			AutoSB = Rayfield.Flags["AutoSB"].CurrentValue,
			GhostESP = Rayfield.Flags["GhostESP"].CurrentValue,
			ItemESP = Rayfield.Flags["ItemESP"].CurrentValue,
			PlayersESP = Rayfield.Flags["PlayersESP"].CurrentValue,
			EvidenceESP = Rayfield.Flags["EvidenceESP"].CurrentValue,
			FullBright = Rayfield.Flags["FullBright"].CurrentValue,
			WalkSpeedSlider = Rayfield.Flags["WalkSpeedSlider"].CurrentValue,
			UpdateDelay = Rayfield.Flags["UpdateDelay"].CurrentValue
		}
		
		writefile(ConfigFolder.."/"..name..".json", HttpService:JSONEncode(config))
		Rayfield:Notify({Title = "Config Saved!", Content = "Successfully saved config: "..name, Duration = 3})
	end,
})

MiscTab:CreateButton({
	Name = "Load Config",
	Callback = function()
		local name = getgenv().XYNCZ_ConfigName
		if not name or name == "" then name = "Default" end
		local path = ConfigFolder.."/"..name..".json"
		
		if isfile(path) then
			local success, data = pcall(function() return HttpService:JSONDecode(readfile(path)) end)
			if success and type(data) == "table" then
				if data.AutoEscape ~= nil then Rayfield.Flags["AutoEscape"]:Set(data.AutoEscape) end
				if data.AutoSB ~= nil then Rayfield.Flags["AutoSB"]:Set(data.AutoSB) end
				if data.GhostESP ~= nil then Rayfield.Flags["GhostESP"]:Set(data.GhostESP) end
				if data.ItemESP ~= nil then Rayfield.Flags["ItemESP"]:Set(data.ItemESP) end
				if data.PlayersESP ~= nil then Rayfield.Flags["PlayersESP"]:Set(data.PlayersESP) end
				if data.EvidenceESP ~= nil then Rayfield.Flags["EvidenceESP"]:Set(data.EvidenceESP) end
				if data.FullBright ~= nil then Rayfield.Flags["FullBright"]:Set(data.FullBright) end
				if data.WalkSpeedSlider ~= nil then Rayfield.Flags["WalkSpeedSlider"]:Set(data.WalkSpeedSlider) end
				if data.UpdateDelay ~= nil then Rayfield.Flags["UpdateDelay"]:Set(data.UpdateDelay) end
				
				Rayfield:Notify({Title = "Config Loaded!", Content = "Successfully loaded config: "..name, Duration = 3})
			else
				Rayfield:Notify({Title = "Error", Content = "Failed to parse Config file!", Duration = 3})
			end
		else
			Rayfield:Notify({Title = "Error", Content = "Config file '"..name.."' not found!", Duration = 3})
		end
	end,
})

--------------------------------------------------------------
------------------------UNLOAD SCRIPT-------------------------
--------------------------------------------------------------
MiscTab:CreateSection("Danger Zone")

MiscTab:CreateButton({
	Name = "Unload Script (Destroy All & Reset)",
	Callback = function()
		getgenv()["DemonologyUI_Rayfield_XYNCZ"] = nil

		if Func then Func:Disconnect() end
		if Func2 then Func2:Disconnect() end
		if FuncEvi then FuncEvi:Disconnect() end

		PlayersEspToggle = false
		EvidenceEspToggle = false
		ItemEspToggle = false
		IsEscapeHunt = false
		AutoSpiritBoxToggle = false

		if GhostBBGui then GhostBBGui:Destroy() end
		if GhostHL then GhostHL:Destroy() end

		for _, v in pairs(ItemEspList) do
			if v then v:Destroy() end
		end
		ItemEspList = {}

		for _, v in pairs(EvidenceEspList) do
			if v then v:Destroy() end
		end
		EvidenceEspList = {}

		UpdatePlrEsp()

		Lighting.Ambient = OldLightingList.Ambient
		Lighting.OutdoorAmbient = OldLightingList.OutdoorAmbient
		Lighting.Brightness = OldLightingList.Brightness
		Lighting.GlobalShadows = OldLightingList.GlobalShadows
		Lighting.FogEnd = OldLightingList.FogEnd

		if plr.Character and plr.Character:FindFirstChild("Humanoid") then
			plr.Character.Humanoid.WalkSpeed = 16
		end

		Rayfield:Destroy()
	end,
})

--------------------------------------------------------------
------------------------AUTO OPEN DOOR------------------------
--------------------------------------------------------------
task.spawn(function()
	task.wait(15)
	local ExitDoorModel = nil
	for _, v in pairs(workspace:GetDescendants()) do
		if v:IsA("Model") and v.Name == "ExitDoor" then
			ExitDoorModel = v
			if v:GetAttribute("DoorClosed") ~= false then
				game:GetService("ReplicatedStorage"):WaitForChild("Events"):WaitForChild("ClientChangeDoorState"):FireServer(ExitDoorModel:WaitForChild("Door"))
			else
				break
			end
		end
	end
end)

Rayfield:LoadConfiguration()

Rayfield:Notify({
    Title = "Demonology Script Loaded",
    Content = "Welcome back, XYNCZ!",
    Duration = 5,
    Image = 4483362458,
})