Acheron Helper

-- =====================================================
-- ACHERON DEMONOLOGY HELPER
-- FIXED VERSION
-- =====================================================

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

local Player = Players.LocalPlayer
local CoreGui = game:GetService("CoreGui")

-- =====================================================
-- CLEAN OLD GUI
-- =====================================================

local OldGui = CoreGui:FindFirstChild("AcheronDemonologyHelper")

if OldGui then
    OldGui:Destroy()
end

-- =====================================================
-- GUI
-- =====================================================

local AcheronGui = Instance.new("ScreenGui")
AcheronGui.Name = "AcheronDemonologyHelper"
AcheronGui.ResetOnSpawn = false
AcheronGui.Parent = CoreGui

local Main = Instance.new("Frame")
Main.Name = "Main"
Main.Size = UDim2.fromOffset(320, 440)
Main.Position = UDim2.new(0.5, -160, 0.5, -220)
Main.BackgroundColor3 = Color3.fromRGB(20, 20, 25)
Main.BorderSizePixel = 0
Main.Active = true
Main.Parent = AcheronGui

local Corner = Instance.new("UICorner")
Corner.CornerRadius = UDim.new(0, 10)
Corner.Parent = Main

-- =====================================================
-- DRAGGING
-- =====================================================

local dragging = false
local dragStart
local startPosition

Main.InputBegan:Connect(function(input)

    if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then

        dragging = true
        dragStart = input.Position
        startPosition = Main.Position

        input.Changed:Connect(function()

            if input.UserInputState == Enum.UserInputState.End then
                dragging = false
            end

        end)
    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

        Main.Position = UDim2.new(
            startPosition.X.Scale,
            startPosition.X.Offset + delta.X,

            startPosition.Y.Scale,
            startPosition.Y.Offset + delta.Y
        )
    end
end)

-- =====================================================
-- TITLE
-- =====================================================

local Title = Instance.new("TextLabel")

Title.Size = UDim2.new(1, -20, 0, 40)
Title.Position = UDim2.fromOffset(10, 5)
Title.BackgroundTransparency = 1
Title.Text = "Acheron Demonology Helper"
Title.TextColor3 = Color3.fromRGB(255, 255, 255)
Title.TextSize = 20
Title.Font = Enum.Font.GothamBold
Title.TextXAlignment = Enum.TextXAlignment.Left
Title.Parent = Main

-- =====================================================
-- EVIDENCE FRAME
-- =====================================================

local EvidenceFrame = Instance.new("Frame")

EvidenceFrame.Size = UDim2.new(1, -20, 0, 275)
EvidenceFrame.Position = UDim2.fromOffset(10, 48)
EvidenceFrame.BackgroundTransparency = 1
EvidenceFrame.Parent = Main

local Layout = Instance.new("UIListLayout")
Layout.Padding = UDim.new(0, 2)
Layout.Parent = EvidenceFrame

local EvidenceLabels = {}

local EvidenceNames = {
    "EMF Level 5",
    "Freezing Temperatures",
    "Handprints",
    "Ghost Orb",
    "Spirit Box",
    "Inscription",
    "Wither",
    "Laser Projector"
}

for _, Name in ipairs(EvidenceNames) do

    local Label = Instance.new("TextLabel")

    Label.Size = UDim2.new(1, 0, 0, 31)
    Label.BackgroundTransparency = 1
    Label.Text = Name .. ": False"
    Label.TextColor3 = Color3.fromRGB(255, 80, 80)
    Label.TextSize = 16
    Label.Font = Enum.Font.Gotham
    Label.TextXAlignment = Enum.TextXAlignment.Left
    Label.Parent = EvidenceFrame

    EvidenceLabels[Name] = Label
end

-- =====================================================
-- TEMPERATURE
-- =====================================================

local TemperatureLabel = Instance.new("TextLabel")

TemperatureLabel.Size = UDim2.new(1, -20, 0, 30)
TemperatureLabel.Position = UDim2.fromOffset(10, 326)
TemperatureLabel.BackgroundTransparency = 1
TemperatureLabel.Text = "Temperature: --.-°C (Unknown)"
TemperatureLabel.TextColor3 = Color3.fromRGB(255, 80, 80)
TemperatureLabel.TextSize = 16
TemperatureLabel.Font = Enum.Font.Gotham
TemperatureLabel.TextXAlignment = Enum.TextXAlignment.Left
TemperatureLabel.Parent = Main

-- =====================================================
-- GHOST DATABASE
-- =====================================================

local GhostEvidence = {

    Aswang = {
        "Wither",
        "EMF Level 5",
        "Inscription"
    },

    Banshee = {
        "Ghost Orb",
        "Handprints",
        "Freezing Temperatures"
    },

    Demon = {
        "EMF Level 5",
        "Handprints",
        "Freezing Temperatures"
    },

    Doppelganger = {
        "Freezing Temperatures",
        "Inscription",
        "Spirit Box"
    },

    Dullahan = {
        "Wither",
        "Laser Projector",
        "Freezing Temperatures"
    },

    Dybbuk = {
        "Wither",
        "Handprints",
        "Freezing Temperatures"
    },

    Entity = {
        "Spirit Box",
        "Handprints",
        "Laser Projector"
    },

    Ghoul = {
        "Spirit Box",
        "Freezing Temperatures",
        "Ghost Orb"
    },

    Keres = {
        "Wither",
        "Handprints",
        "Spirit Box"
    },

    Leviathan = {
        "Ghost Orb",
        "Inscription",
        "Handprints"
    },

    Nightmare = {
        "EMF Level 5",
        "Spirit Box",
        "Ghost Orb"
    },

    Oni = {
        "Spirit Box",
        "Freezing Temperatures",
        "Laser Projector"
    },

    Phantom = {
        "EMF Level 5",
        "Handprints",
        "Ghost Orb"
    },

    Ravager = {
        "EMF Level 5",
        "Handprints",
        "Laser Projector"
    },

    Revenant = {
        "Inscription",
        "EMF Level 5",
        "Freezing Temperatures"
    },

    Shadow = {
        "EMF Level 5",
        "Inscription",
        "Laser Projector"
    },

    Siren = {
        "Wither",
        "Spirit Box",
        "EMF Level 5"
    },

    Specter = {
        "EMF Level 5",
        "Freezing Temperatures",
        "Laser Projector"
    },

    Spirit = {
        "Handprints",
        "Inscription",
        "Spirit Box"
    },

    ["The Wisp"] = {
        "Wither",
        "Laser Projector",
        "Ghost Orb"
    },

    Umbra = {
        "Ghost Orb",
        "Laser Projector",
        "Handprints"
    },

    Vesper = {
        "Inscription",
        "Wither",
        "Handprints"
    },

    Vex = {
        "Wither",
        "Ghost Orb",
        "Freezing Temperatures"
    },

    Wraith = {
        "EMF Level 5",
        "Spirit Box",
        "Laser Projector"
    },

    Wretch = {
        "EMF Level 5",
        "Inscription",
        "Laser Projector"
    }
}

-- =====================================================
-- GHOST RESULT
-- =====================================================

local GhostResult = Instance.new("TextLabel")

GhostResult.Size = UDim2.new(1, -20, 0, 45)
GhostResult.Position = UDim2.fromOffset(10, 360)
GhostResult.BackgroundTransparency = 1
GhostResult.Text = "Ghost: Unknown"
GhostResult.TextColor3 = Color3.fromRGB(255, 255, 255)
GhostResult.TextSize = 20
GhostResult.Font = Enum.Font.GothamBold
GhostResult.TextXAlignment = Enum.TextXAlignment.Left
GhostResult.Parent = Main

-- =====================================================
-- CONFIRMED EVIDENCE
-- =====================================================

local ConfirmedEvidence = {}

for _, Name in ipairs(EvidenceNames) do
    ConfirmedEvidence[Name] = false
end

-- =====================================================
-- SAFE TEMPERATURE DETECTION
-- =====================================================

local function GetTemperature()

    local Map = workspace:FindFirstChild("Map")

    if not Map then
        return nil, nil
    end

    local Rooms = Map:FindFirstChild("Rooms")

    if not Rooms then
        return nil, nil
    end

    local LowestTemp = nil
    local LowestRoom = nil

    for _, Room in ipairs(Rooms:GetChildren()) do

        local Temp = Room:GetAttribute("Temperature")

        if typeof(Temp) == "number" then

            if LowestTemp == nil or Temp < LowestTemp then
                LowestTemp = Temp
                LowestRoom = Room
            end
        end
    end

    return LowestTemp, LowestRoom
end

local function DetectFreezing(Temp)

    return Temp ~= nil and Temp < 0
end

-- =====================================================
-- HANDPRINTS
-- =====================================================

local function DetectHandprints()

    for _, Obj in ipairs(workspace:GetDescendants()) do

        if Obj:IsA("BasePart") then

            if Obj.Name == "Handprint1"
                or Obj.Name == "Handprint2"
                or Obj.Name == "Footprint"
                or Obj.Name == "Footprint1" then

                return true
            end
        end
    end

    return false
end

-- =====================================================
-- GHOST ORB
-- =====================================================

local function DetectGhostOrb()

    for _, Obj in ipairs(workspace:GetDescendants()) do

        if Obj:IsA("BasePart")
            and Obj.Name == "GhostOrb" then

            return true
        end
    end

    return false
end

-- =====================================================
-- EMF
-- =====================================================

local function GetEMFLevel()

    local Level = 0

    for _, Obj in ipairs(workspace:GetDescendants()) do

        if Obj:IsA("Folder")
            and Obj.Name == "Indicators" then

            for _, V in ipairs(Obj:GetChildren()) do

                if V:IsA("BasePart")
                    and V.Material == Enum.Material.Neon then

                    local Number = tonumber(V.Name)

                    if Number and Number > Level then
                        Level = Number
                    end
                end
            end
        end
    end

    return Level
end

-- =====================================================
-- WITHER
-- =====================================================

local function DetectWither()

    local Items = workspace:FindFirstChild("Items")

    if not Items then
        return false
    end

    for _, Obj in ipairs(Items: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

-- =====================================================
-- INSCRIPTION
-- =====================================================

local function CheckSpiritBook(Container)

    if not Container then
        return false
    end

    for _, Obj in ipairs(Container: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 DetectInscription()

    if CheckSpiritBook(workspace:FindFirstChild("Items")) then
        return true
    end

    if CheckSpiritBook(Player.Character) then
        return true
    end

    return false
end

-- =====================================================
-- SPIRIT BOX
-- =====================================================

local function DetectSpiritBox()

    local PlayerGui = Player:FindFirstChild("PlayerGui")

    if not PlayerGui then
        return false
    end

    local Subtitles = PlayerGui:FindFirstChild("Subtitles")

    if not Subtitles then
        return false
    end

    local Holder = Subtitles:FindFirstChild("Holder")

    if not Holder then
        return false
    end

    local TextLabel = Holder:FindFirstChild("TextLabel")

    if not TextLabel then
        return false
    end

    local GhostText = TextLabel.Text or ""

    return #GhostText:gsub("%s+", "") >= 3
end

-- =====================================================
-- LASER PROJECTOR
-- =====================================================

local function DetectLaser()

    local Ghost = workspace:FindFirstChild("Ghost")

    if not Ghost then
        return false
    end

    return Ghost:GetAttribute("InLaser") == true
end

-- =====================================================
-- UPDATE CONFIRMED EVIDENCE
-- =====================================================

local function UpdateConfirmedEvidence(Current)

    if Current.EMFLevel == 5 then
        ConfirmedEvidence["EMF Level 5"] = true
    end

    if Current["Freezing Temperatures"] then
        ConfirmedEvidence["Freezing Temperatures"] = true
    end

    if Current["Handprints"] then
        ConfirmedEvidence["Handprints"] = true
    end

    if Current["Ghost Orb"] then
        ConfirmedEvidence["Ghost Orb"] = true
    end

    if Current["Spirit Box"] then
        ConfirmedEvidence["Spirit Box"] = true
    end

    if Current["Inscription"] then
        ConfirmedEvidence["Inscription"] = true
    end

    if Current["Wither"] then
        ConfirmedEvidence["Wither"] = true
    end

    if Current["Laser Projector"] then
        ConfirmedEvidence["Laser Projector"] = true
    end
end

-- =====================================================
-- GET EVIDENCE
-- =====================================================

local function GetEvidence()

    local Temp, TempRoom = GetTemperature()
    local EMF = GetEMFLevel()

    local Current = {

        ["EMF Level 5"] = EMF == 5,

        ["Freezing Temperatures"] =
            DetectFreezing(Temp),

        ["Handprints"] =
            DetectHandprints(),

        ["Ghost Orb"] =
            DetectGhostOrb(),

        ["Spirit Box"] =
            DetectSpiritBox(),

        ["Inscription"] =
            DetectInscription(),

        ["Wither"] =
            DetectWither(),

        ["Laser Projector"] =
            DetectLaser(),

        EMFLevel = EMF,

        Temperature = Temp,

        TemperatureRoom = TempRoom
    }

    UpdateConfirmedEvidence(Current)

    for _, Name in ipairs(EvidenceNames) do
        Current[Name] = ConfirmedEvidence[Name]
    end

    return Current
end

-- =====================================================
-- IDENTIFY GHOST
-- =====================================================

local function IdentifyGhost(Evidence)

    local Matches = {}

    for GhostName, RequiredEvidence in pairs(GhostEvidence) do

        local Match = true

        for _, RequiredEvidenceName in ipairs(RequiredEvidence) do

            if Evidence[RequiredEvidenceName] ~= true then
                Match = false
                break
            end
        end

        if Match then
            table.insert(Matches, GhostName)
        end
    end

    if #Matches == 1 then
        return Matches[1]

    elseif #Matches > 1 then
        table.sort(Matches)
        return table.concat(Matches, " / ")
    end

    return "Unknown"
end

-- =====================================================
-- UPDATE UI
-- =====================================================

local function UpdateUI()

    local Evidence = GetEvidence()

    -- =============================================
    -- EVIDENCE
    -- =============================================

    for _, Name in ipairs(EvidenceNames) do

        local Label = EvidenceLabels[Name]
        local State = Evidence[Name] == true

        if Name == "EMF Level 5" then

            if State then

                Label.Text = "EMF 5: True"
                Label.TextColor3 =
                    Color3.fromRGB(0, 255, 120)

            else

                Label.Text =
                    "EMF Level: " ..
                    tostring(Evidence.EMFLevel or 0)

                Label.TextColor3 =
                    Color3.fromRGB(255, 80, 80)
            end

        else

            Label.Text =
                Name .. ": " .. tostring(State)

            if State then

                Label.TextColor3 =
                    Color3.fromRGB(0, 255, 120)

            else

                Label.TextColor3 =
                    Color3.fromRGB(255, 80, 80)
            end
        end
    end

    -- =============================================
    -- TEMPERATURE
    -- =============================================

    if Evidence.Temperature ~= nil
        and Evidence.TemperatureRoom then

        TemperatureLabel.Text = string.format(
            "Temperature: %.1f°C (%s)",
            Evidence.Temperature,
            Evidence.TemperatureRoom.Name
        )

        if Evidence.Temperature < 0 then

            TemperatureLabel.TextColor3 =
                Color3.fromRGB(0, 255, 120)

        else

            TemperatureLabel.TextColor3 =
                Color3.fromRGB(255, 80, 80)
        end

    else

        TemperatureLabel.Text =
            "Temperature: --.-°C (Unknown)"

        TemperatureLabel.TextColor3 =
            Color3.fromRGB(255, 80, 80)
    end

    -- =============================================
    -- GHOST
    -- =============================================

    local Ghost = IdentifyGhost(Evidence)

    GhostResult.Text =
        "Ghost: " .. Ghost

    if Ghost ~= "Unknown" then

        GhostResult.TextColor3 =
            Color3.fromRGB(0, 255, 120)

    else

        GhostResult.TextColor3 =
            Color3.fromRGB(255, 255, 255)
    end
end

-- =====================================================
-- UPDATE LOOP
-- =====================================================

task.spawn(function()

    while AcheronGui.Parent do

        local Success, Error =
            pcall(UpdateUI)

        if not Success then
            warn("[Acheron] Update error:", Error)
        end

        task.wait(0.5)
    end
end)