local Rayfield = loadstring(game:HttpGet("https://sirius.menu/rayfield"))()

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

local Player = Players.LocalPlayer

local SpeedEnabled = false
local TPWalkSpeed = 5
local AnchorLoopID = 0

local NoClipEnabled = false
local OriginalCollision = {}

local FullBrightEnabled = false
local ThirdPersonEnabled = false

local POVEnabled = false
local POVValue = 90

local Camera = workspace.CurrentCamera
local OriginalPOV = Camera and Camera.FieldOfView or 70

local OriginalLighting = {
    Brightness = Lighting.Brightness,
    ClockTime = Lighting.ClockTime,
    FogEnd = Lighting.FogEnd,
    GlobalShadows = Lighting.GlobalShadows,
    Ambient = Lighting.Ambient,
    OutdoorAmbient = Lighting.OutdoorAmbient,
    ExposureCompensation = Lighting.ExposureCompensation
}

local function GetCharacter()
    return Player.Character
end

local function GetHumanoid()
    local Character = GetCharacter()
    if not Character then
        return nil
    end

    return Character:FindFirstChildOfClass("Humanoid")
end

local function GetRoot()
    local Character = GetCharacter()
    if not Character then
        return nil
    end

    return Character:FindFirstChild("HumanoidRootPart")
end

local function IsFirstPerson(CurrentCamera)
    if not CurrentCamera then
        return false
    end

    return (
        CurrentCamera.CFrame.Position -
        CurrentCamera.Focus.Position
    ).Magnitude <= 1.5
end

local function StopAnchorLoop()
    AnchorLoopID += 1

    local Root = GetRoot()

    if Root then
        Root.Anchored = false
    end
end

local function StartAnchorLoop()
    AnchorLoopID += 1

    local ThisLoop = AnchorLoopID

    task.spawn(function()
        while SpeedEnabled and ThisLoop == AnchorLoopID do
            local Root = GetRoot()

            if Root then
                Root.Anchored = true
            end

            task.wait(0.2)

            if not SpeedEnabled or ThisLoop ~= AnchorLoopID then
                break
            end

            Root = GetRoot()

            if Root then
                Root.Anchored = false
            end

            task.wait(0.2)
        end

        local Root = GetRoot()

        if Root then
            Root.Anchored = false
        end
    end)
end

RunService.Heartbeat:Connect(function(Delta)
    if not SpeedEnabled then
        return
    end

    local Character = GetCharacter()
    local Humanoid = GetHumanoid()

    if not Character or not Humanoid then
        return
    end

    local Direction = Humanoid.MoveDirection

    if Direction.Magnitude > 0 then
        Character:TranslateBy(
            Direction * TPWalkSpeed * Delta * 10
        )
    end
end)

local function SaveCollisionStates()
    table.clear(OriginalCollision)

    local Character = GetCharacter()

    if not Character then
        return
    end

    for _, Part in ipairs(Character:GetDescendants()) do
        if Part:IsA("BasePart") then
            OriginalCollision[Part] = Part.CanCollide
        end
    end
end

local function ApplyNoClip()
    local Character = GetCharacter()

    if not Character then
        return
    end

    for _, Part in ipairs(Character:GetDescendants()) do
        if Part:IsA("BasePart") then
            if OriginalCollision[Part] == nil then
                OriginalCollision[Part] = Part.CanCollide
            end

            Part.CanCollide = false
        end
    end

    local Collision = Character:FindFirstChild("Collision")

    if Collision and Collision:IsA("BasePart") then
        Collision.CanCollide = false
    end
end

local function RestoreCollisionStates()
    for Part, State in pairs(OriginalCollision) do
        if Part and Part.Parent then
            Part.CanCollide = State
        end
    end

    table.clear(OriginalCollision)
end

local function DetectWall()
    if not NoClipEnabled then
        return nil
    end

    local Character = GetCharacter()
    local Root = GetRoot()
    local Humanoid = GetHumanoid()

    if not Character or not Root or not Humanoid then
        return nil
    end

    local Direction

    if Humanoid.MoveDirection.Magnitude > 0.05 then
        Direction = Humanoid.MoveDirection.Unit
    else
        Direction = Root.CFrame.LookVector
    end

    local Params = RaycastParams.new()

    Params.FilterType = Enum.RaycastFilterType.Exclude
    Params.FilterDescendantsInstances = {
        Character
    }

    Params.IgnoreWater = true

    local Result = workspace:Raycast(
        Root.Position,
        Direction * 2.5,
        Params
    )

    if Result
        and Result.Instance
        and Result.Instance:IsA("BasePart")
        and Result.Instance.CanCollide then

        return Result
    end

    return nil
end

RunService.Stepped:Connect(function()
    if NoClipEnabled then
        ApplyNoClip()
        DetectWall()
    end
end)

workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
    Camera = workspace.CurrentCamera

    if Camera and not POVEnabled then
        OriginalPOV = Camera.FieldOfView
    end
end)

RunService:BindToRenderStep(
    "VisualController",
    Enum.RenderPriority.Camera.Value + 1,

    function()
        if FullBrightEnabled then
            Lighting.Brightness = 3
            Lighting.ClockTime = 14
            Lighting.FogEnd = 100000
            Lighting.GlobalShadows = false
            Lighting.Ambient = Color3.fromRGB(255, 255, 255)
            Lighting.OutdoorAmbient = Color3.fromRGB(255, 255, 255)
            Lighting.ExposureCompensation = 0.5
        end

        local CurrentCamera = workspace.CurrentCamera

        if CurrentCamera then
            if POVEnabled then
                CurrentCamera.FieldOfView = POVValue
            end

            if ThirdPersonEnabled and IsFirstPerson(CurrentCamera) then
                CurrentCamera.CFrame =
                    CurrentCamera.CFrame *
                    CFrame.new(0, 0, 10)
            end
        end
    end
)

Player.CharacterAdded:Connect(function(Character)
    Character:WaitForChild("Humanoid", 10)

    local Root = Character:WaitForChild(
        "HumanoidRootPart",
        10
    )

    table.clear(OriginalCollision)

    if Root then
        Root.Anchored = false
    end

    task.wait(0.4)

    if NoClipEnabled then
        SaveCollisionStates()
        ApplyNoClip()
    end

    if SpeedEnabled then
        StartAnchorLoop()
    end
end)

local function CreateTheme(
    Background,
    Topbar,
    Element,
    ElementHover,
    Accent,
    AccentBright,
    Text
)
    return {
        TextFont = "Default",
        TextColor = Text,

        Background = Background,
        Topbar = Topbar,
        Shadow = Color3.fromRGB(10, 10, 10),

        NotificationBackground = Element,
        NotificationActionsBackground = Text,

        TabBackground = Element,
        TabStroke = ElementHover,
        TabBackgroundSelected = Accent,

        TabTextColor = Text,
        SelectedTabTextColor = Text,

        ElementBackground = Element,
        ElementBackgroundHover = ElementHover,

        SecondaryElementBackground = Background,

        ElementStroke = ElementHover,
        SecondaryElementStroke = Element,

        SliderBackground = Accent,
        SliderProgress = AccentBright,
        SliderStroke = AccentBright,

        ToggleBackground = Element,

        ToggleEnabled = Accent,
        ToggleDisabled = ElementHover,

        ToggleEnabledStroke = AccentBright,
        ToggleDisabledStroke = ElementHover,

        ToggleEnabledOuterStroke = Accent,
        ToggleDisabledOuterStroke = Element,

        DropdownSelected = Accent,
        DropdownUnselected = Element,

        InputBackground = Element,
        InputStroke = Accent,

        PlaceholderColor = Color3.fromRGB(150, 150, 150)
    }
end

local Themes = {}

Themes.Red = CreateTheme(
    Color3.fromRGB(22, 14, 14),
    Color3.fromRGB(32, 18, 18),
    Color3.fromRGB(42, 23, 23),
    Color3.fromRGB(55, 30, 30),
    Color3.fromRGB(180, 35, 35),
    Color3.fromRGB(240, 70, 70),
    Color3.fromRGB(255, 235, 235)
)

Themes.Amber = CreateTheme(
    Color3.fromRGB(28, 21, 12),
    Color3.fromRGB(39, 29, 15),
    Color3.fromRGB(50, 37, 20),
    Color3.fromRGB(65, 47, 24),
    Color3.fromRGB(210, 125, 20),
    Color3.fromRGB(255, 175, 45),
    Color3.fromRGB(255, 244, 220)
)

Themes.Purple = CreateTheme(
    Color3.fromRGB(19, 15, 27),
    Color3.fromRGB(28, 20, 39),
    Color3.fromRGB(38, 27, 52),
    Color3.fromRGB(51, 35, 70),
    Color3.fromRGB(125, 65, 200),
    Color3.fromRGB(175, 100, 255),
    Color3.fromRGB(245, 235, 255)
)

Themes.Cyan = CreateTheme(
    Color3.fromRGB(11, 21, 24),
    Color3.fromRGB(15, 30, 34),
    Color3.fromRGB(20, 42, 47),
    Color3.fromRGB(26, 55, 61),
    Color3.fromRGB(20, 150, 170),
    Color3.fromRGB(50, 220, 240),
    Color3.fromRGB(225, 250, 255)
)

Themes.Emerald = CreateTheme(
    Color3.fromRGB(12, 23, 18),
    Color3.fromRGB(16, 33, 25),
    Color3.fromRGB(21, 45, 34),
    Color3.fromRGB(27, 59, 43),
    Color3.fromRGB(30, 155, 90),
    Color3.fromRGB(60, 220, 130),
    Color3.fromRGB(225, 255, 238)
)

Themes.Midnight = CreateTheme(
    Color3.fromRGB(12, 15, 25),
    Color3.fromRGB(17, 21, 34),
    Color3.fromRGB(23, 29, 45),
    Color3.fromRGB(30, 38, 58),
    Color3.fromRGB(50, 90, 190),
    Color3.fromRGB(85, 135, 255),
    Color3.fromRGB(230, 238, 255)
)

local Window = Rayfield:CreateWindow({
    Name = "Doors | Open Source",
    Icon = 0,

    LoadingTitle = "Doors | Open Source",
    LoadingSubtitle = "bigburgertv",

    ShowText = "Doors | Open Source",

    Theme = "Default",

    ToggleUIKeybind = "K",

    ConfigurationSaving = {
        Enabled = false
    },

    Discord = {
        Enabled = false
    },

    KeySystem = true,

    KeySettings = {
        Title = "Doors | Open Source",
        Subtitle = "Key System",
        Note = "Key: bigburgertv",

        FileName = "MovementHubKey",
        SaveKey = true,

        GrabKeyFromSite = false,

        Key = {
            "bigburgertv"
        }
    }
})

local MainTab = Window:CreateTab("Main")
local ExtrasTab = Window:CreateTab("Extras")

MainTab:CreateSection("Movement")

MainTab:CreateToggle({
    Name = "Speed",
    CurrentValue = false,
    Flag = "TPWalkSpeed",

    Callback = function(Value)
        SpeedEnabled = Value

        if Value then
            StartAnchorLoop()
        else
            StopAnchorLoop()
        end
    end
})

MainTab:CreateSlider({
    Name = "Speed Scale",

    Range = {
        1,
        10
    },

    Increment = 0.5,
    Suffix = "",
    CurrentValue = 5,

    Flag = "TPWalkSpeedScale",

    Callback = function(Value)
        TPWalkSpeed = Value
    end
})

MainTab:CreateToggle({
    Name = "Noclip",
    CurrentValue = false,
    Flag = "Noclip",

    Callback = function(Value)
        NoClipEnabled = Value

        if Value then
            SaveCollisionStates()
            ApplyNoClip()
        else
            RestoreCollisionStates()
        end
    end
})

ExtrasTab:CreateSection("Visuals")

ExtrasTab:CreateToggle({
    Name = "Full Bright",
    CurrentValue = false,
    Flag = "FullBright",

    Callback = function(Value)
        FullBrightEnabled = Value

        if not Value then
            Lighting.Brightness =
                OriginalLighting.Brightness

            Lighting.ClockTime =
                OriginalLighting.ClockTime

            Lighting.FogEnd =
                OriginalLighting.FogEnd

            Lighting.GlobalShadows =
                OriginalLighting.GlobalShadows

            Lighting.Ambient =
                OriginalLighting.Ambient

            Lighting.OutdoorAmbient =
                OriginalLighting.OutdoorAmbient

            Lighting.ExposureCompensation =
                OriginalLighting.ExposureCompensation
        end
    end
})

ExtrasTab:CreateToggle({
    Name = "Third Person",
    CurrentValue = false,
    Flag = "ThirdPerson",

    Callback = function(Value)
        ThirdPersonEnabled = Value
    end
})

ExtrasTab:CreateToggle({
    Name = "POV",
    CurrentValue = false,
    Flag = "POVEnabled",

    Callback = function(Value)
        POVEnabled = Value

        local CurrentCamera =
            workspace.CurrentCamera

        if not Value and CurrentCamera then
            CurrentCamera.FieldOfView =
                OriginalPOV
        end
    end
})

ExtrasTab:CreateSlider({
    Name = "POV Scale",

    Range = {
        70,
        120
    },

    Increment = 1,
    Suffix = "",
    CurrentValue = 90,

    Flag = "POVScale",

    Callback = function(Value)
        POVValue = Value

        if POVEnabled then
            local CurrentCamera =
                workspace.CurrentCamera

            if CurrentCamera then
                CurrentCamera.FieldOfView =
                    POVValue
            end
        end
    end
})

ExtrasTab:CreateSection("UI Theme")

ExtrasTab:CreateDropdown({
    Name = "Theme",

    Options = {
        "Default",
        "Red",
        "Amber",
        "Purple",
        "Cyan",
        "Emerald",
        "Midnight"
    },

    CurrentOption = {
        "Default"
    },

    MultipleOptions = false,

    Flag = "UITheme",

    Callback = function(Options)
        local Selected

        if typeof(Options) == "table" then
            Selected = Options[1]
        else
            Selected = Options
        end

        if not Selected then
            return
        end

        pcall(function()
            if Selected == "Default" then
                Window.ModifyTheme("Default")
            elseif Themes[Selected] then
                Window.ModifyTheme(
                    Themes[Selected]
                )
            end
        end)
    end
})

print("Doors | Open Source loaded")
print("Press K to toggle the UI")