--[[
    Universal Cheat Script
    Framework: Rayfield UI
    Version: 3.8
    Creator: Gemini
--]]

local Rayfield = loadstring(game:HttpGet('https://sirius.menu/rayfield'))()
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Players = game:GetService("Players")

-- Settings (Global)
local Camera = workspace.CurrentCamera
local LocalPlayer = Players.LocalPlayer
local Mouse = LocalPlayer:GetMouse()

-- State Variables
local ESP_Enabled = false
local VisibleColor = Color3.fromRGB(0, 255, 0)
local HiddenColor = Color3.fromRGB(255, 0, 0)

local Aimbot_Enabled = false
local Aimbot_Smoothing = 1
local Aimbot_Key = Enum.KeyCode.E
local Aimbot_FOV_Enabled = false
local Aimbot_FOV_Radius = 100
local Aimbot_FOV_Color = Color3.fromRGB(255, 255, 255)

-- Movement Variables
local WalkSpeed_Value = 16
local JumpPower_Value = 50
local InfiniteJump_Enabled = false
local Noclip_Enabled = false
local ClickTP_Enabled = false
local ClickTP_Key = Enum.KeyCode.LeftControl

-- Fly Variables
local Fly_Enabled = false
local Fly_Speed = 50
local Fly_Key = Enum.KeyCode.F
local Fly_BodyVelocity = nil
local Fly_BodyGyro = nil

-- Utility Variables
local Freecam_Enabled = false
local Freecam_Part = nil
local Spectating_Player = nil
local TeleportLocations = {} 
local TeleportInputName = "Position 1"
local SelectedTPTarget = nil

local Float_Enabled = false
local Float_Part = nil
local Float_Height = nil -- Variabel för att låsa höjden

local AntiSlap_Enabled = false
local LastSafeCFrame = nil

local WalkOnVoid_Enabled = false
local Void_Part = nil
local Void_Height = -50 

-- Active Values
local Active_WalkSpeed = 16
local Active_JumpPower = 50

-- FOV Circle Object
local FOVCircle = Drawing.new("Circle")
FOVCircle.Thickness = 1
FOVCircle.NumSides = 100
FOVCircle.Filled = false
FOVCircle.Transparency = 1

local Window = Rayfield:CreateWindow({
   Name = "Universal Cheat",
   LoadingTitle = "Starting System...",
   LoadingSubtitle = "by Gemini",
   Theme = "Ocean"
})

local CombatTab = Window:CreateTab("Combat", "crosshair")
local VisualsTab = Window:CreateTab("Visuals", "eye")
local MovementTab = Window:CreateTab("Movement", "zap")
local UtilityTab = Window:CreateTab("Utility", "wrench")

-- Utility Functions
local function GetHead(character)
    return character:FindFirstChild("Head") or character:FindFirstChild("UpperTorso") or character:FindFirstChild("HumanoidRootPart")
end

local function IsVisible(targetCharacter)
    if not targetCharacter then return false end
    local head = GetHead(targetCharacter)
    if not head then return false end
    
    local raycastParams = RaycastParams.new()
    raycastParams.FilterDescendantsInstances = {LocalPlayer.Character, targetCharacter, Camera}
    raycastParams.FilterType = Enum.RaycastFilterType.Exclude
    raycastParams.IgnoreWater = true
    
    local result = workspace:Raycast(Camera.CFrame.Position, head.Position - Camera.CFrame.Position, raycastParams)
    return result == nil
end

-- ==========================================
-- COMBAT UI
-- ==========================================
CombatTab:CreateSection("Aimbot Control")

CombatTab:CreateToggle({
    Name = "Enable Aimbot",
    CurrentValue = false,
    Flag = "Aim_Enabled",
    Callback = function(Value) Aimbot_Enabled = Value end,
})

CombatTab:CreateLabel("Key: Hold [E] to aim")

CombatTab:CreateSlider({
    Name = "Smoothing",
    Range = {1, 20},
    Increment = 1,
    CurrentValue = 1,
    Flag = "Aim_Smooth",
    Callback = function(Value) Aimbot_Smoothing = Value end,
})

CombatTab:CreateSection("FOV Settings")

CombatTab:CreateToggle({
    Name = "Show FOV Circle",
    CurrentValue = false,
    Flag = "FOV_Enabled",
    Callback = function(Value) Aimbot_FOV_Enabled = Value end,
})

CombatTab:CreateSlider({
    Name = "FOV Radius",
    Range = {10, 800},
    Increment = 10,
    CurrentValue = 100,
    Flag = "FOV_Radius",
    Callback = function(Value) Aimbot_FOV_Radius = Value end,
})

CombatTab:CreateColorPicker({
    Name = "FOV Circle Color",
    Color = Aimbot_FOV_Color,
    Flag = "FOV_Col",
    Callback = function(Value) Aimbot_FOV_Color = Value end,
})

-- ==========================================
-- VISUALS UI
-- ==========================================
VisualsTab:CreateSection("ESP Control")

VisualsTab:CreateToggle({
    Name = "Enable ESP", 
    CurrentValue = false, 
    Flag = "ESP_T",
    Callback = function(V) ESP_Enabled = V end
})

VisualsTab:CreateColorPicker({
    Name = "Color: Visible",
    Color = VisibleColor,
    Flag = "Vis_Col",
    Callback = function(Value) VisibleColor = Value end
})

VisualsTab:CreateColorPicker({
    Name = "Color: Hidden",
    Color = HiddenColor,
    Flag = "Hid_Col",
    Callback = function(Value) HiddenColor = Value end
})

-- ==========================================
-- MOVEMENT UI
-- ==========================================
MovementTab:CreateSection("Character Settings")

MovementTab:CreateSlider({
    Name = "WalkSpeed",
    Range = {16, 500},
    Increment = 1,
    Suffix = " spd",
    CurrentValue = 16,
    Callback = function(Value) WalkSpeed_Value = Value end,
})

MovementTab:CreateSlider({
    Name = "JumpPower",
    Range = {50, 500},
    Increment = 1,
    Suffix = " pwr",
    CurrentValue = 50,
    Callback = function(Value) JumpPower_Value = Value end,
})

MovementTab:CreateButton({
    Name = "Apply Settings",
    Callback = function()
        Active_WalkSpeed = WalkSpeed_Value
        Active_JumpPower = JumpPower_Value
        local humanoid = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("Humanoid")
        if humanoid then
            humanoid.WalkSpeed = Active_WalkSpeed
            humanoid.JumpPower = Active_JumpPower
        end
    end,
})

MovementTab:CreateSection("Fly")
local FlyToggle = MovementTab:CreateToggle({
    Name = "Enable Fly",
    CurrentValue = false,
    Callback = function(Value) Fly_Enabled = Value end,
})

MovementTab:CreateSlider({
    Name = "Fly Speed",
    Range = {10, 500},
    Increment = 1,
    Suffix = " spd",
    CurrentValue = 50,
    Flag = "Fly_Spd",
    Callback = function(Value) Fly_Speed = Value end,
})

MovementTab:CreateKeybind({
    Name = "Fly Keybind",
    CurrentKeybind = "F",
    Callback = function()
        Fly_Enabled = not Fly_Enabled
        FlyToggle:Set(Fly_Enabled)
    end,
})

MovementTab:CreateSection("Special Movement")
MovementTab:CreateToggle({
    Name = "Noclip",
    CurrentValue = false,
    Callback = function(Value) Noclip_Enabled = Value end,
})
MovementTab:CreateToggle({
    Name = "Click TP (Left Control + Click)",
    CurrentValue = false,
    Callback = function(Value) ClickTP_Enabled = Value end,
})
MovementTab:CreateToggle({
    Name = "Infinite Jump",
    CurrentValue = false,
    Callback = function(Value) InfiniteJump_Enabled = Value end,
})

-- ==========================================
-- UTILITY UI
-- ==========================================
UtilityTab:CreateSection("Defensive")
UtilityTab:CreateToggle({
    Name = "Anti Slap",
    CurrentValue = false,
    Callback = function(Value) AntiSlap_Enabled = Value end,
})

UtilityTab:CreateSection("World & Levels")
UtilityTab:CreateToggle({
    Name = "Walk on Void",
    CurrentValue = false,
    Callback = function(Value)
        WalkOnVoid_Enabled = Value
        if not Value then
            if Void_Part then Void_Part:Destroy() Void_Part = nil end
        end
    end,
})

UtilityTab:CreateToggle({
    Name = "Float (Locked Height)",
    CurrentValue = false,
    Callback = function(Value)
        Float_Enabled = Value
        -- Reset höjd när man stänger av
        if not Value then
            if Float_Part then Float_Part:Destroy() Float_Part = nil end
            Float_Height = nil
        end
    end,
})

UtilityTab:CreateSection("Teleport Manager")
UtilityTab:CreateInput({
   Name = "Namn på plats",
   PlaceholderText = "Ex: Bas...",
   Callback = function(Text) TeleportInputName = Text end,
})
UtilityTab:CreateButton({
    Name = "Spara nuvarande position",
    Callback = function()
        local rootPart = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
        if rootPart then
            local name = TeleportInputName
            TeleportLocations[name] = rootPart.CFrame
            UtilityTab:CreateButton({
                Name = "Gå till: " .. name,
                Callback = function()
                    if LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart") then
                        LocalPlayer.Character.HumanoidRootPart.CFrame = TeleportLocations[name]
                    end
                end,
            })
        end
    end,
})

UtilityTab:CreateSection("Teleport to Player")
local PlayerTPDropdown = UtilityTab:CreateDropdown({
    Name = "Välj spelare att TP till",
    Options = {"None"},
    CurrentOption = {"None"},
    Callback = function(Option) SelectedTPTarget = Option[1] end,
})

UtilityTab:CreateButton({
    Name = "Teleportera till vald spelare",
    Callback = function()
        if SelectedTPTarget and SelectedTPTarget ~= "None" then
            local target = Players:FindFirstChild(SelectedTPTarget)
            if target and target.Character and target.Character:FindFirstChild("HumanoidRootPart") then
                LocalPlayer.Character.HumanoidRootPart.CFrame = target.Character.HumanoidRootPart.CFrame * CFrame.new(0, 0, 3)
            end
        end
    end,
})

UtilityTab:CreateSection("Freecamera")
UtilityTab:CreateToggle({
    Name = "Enable Freecam",
    CurrentValue = false,
    Callback = function(Value)
        Freecam_Enabled = Value
        if Value then
            local char = LocalPlayer.Character
            if char and char:FindFirstChild("HumanoidRootPart") then
                Freecam_Part = Instance.new("Part")
                Freecam_Part.Name = "FreecamPart"
                Freecam_Part.Anchored = true
                Freecam_Part.CanCollide = false
                Freecam_Part.Transparency = 1
                Freecam_Part.CFrame = Camera.CFrame
                Freecam_Part.Parent = workspace
                Camera.CameraSubject = Freecam_Part
            end
        else
            if Freecam_Part then Freecam_Part:Destroy() Freecam_Part = nil end
            local char = LocalPlayer.Character
            if char and char:FindFirstChild("Humanoid") then
                Camera.CameraSubject = char.Humanoid
                Camera.CameraType = Enum.CameraType.Custom
            end
        end
    end,
})

UtilityTab:CreateSection("Spectate Player")
local SpectateDropdown = UtilityTab:CreateDropdown({
    Name = "Välj spelare",
    Options = {"None"},
    CurrentOption = {"None"},
    Callback = function(Option)
        local targetName = Option[1]
        if targetName == "None" then
            Spectating_Player = nil
            if LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("Humanoid") then
                Camera.CameraSubject = LocalPlayer.Character.Humanoid
            end
        else
            local target = Players:FindFirstChild(targetName)
            if target and target.Character and target.Character:FindFirstChild("Humanoid") then
                Spectating_Player = target
                Camera.CameraSubject = target.Character.Humanoid
            end
        end
    end,
})

UtilityTab:CreateButton({
    Name = "Uppdatera spelarlistor",
    Callback = function()
        local names = {"None"}
        for _, p in pairs(Players:GetPlayers()) do
            if p ~= LocalPlayer then table.insert(names, p.Name) end
        end
        SpectateDropdown:Refresh(names, true)
        PlayerTPDropdown:Refresh(names, true)
    end,
})

-- ==========================================
-- LOGIC LOOP
-- ==========================================

Mouse.Button1Down:Connect(function()
    if ClickTP_Enabled and UserInputService:IsKeyDown(ClickTP_Key) then
        local root = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
        if root and Mouse.Hit then
            root.CFrame = CFrame.new(Mouse.Hit.Position + Vector3.new(0, 3, 0))
        end
    end
end)

UserInputService.JumpRequest:Connect(function()
    if InfiniteJump_Enabled and LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("Humanoid") then
        LocalPlayer.Character.Humanoid:ChangeState("Jumping")
    end
end)

RunService.RenderStepped:Connect(function()
    local char = LocalPlayer.Character
    local hum = char and char:FindFirstChild("Humanoid")
    local root = char and char:FindFirstChild("HumanoidRootPart")

    -- Anti Slap
    if AntiSlap_Enabled and root and hum and hum.Health > 0 then
        local isMoving = UserInputService:IsKeyDown(Enum.KeyCode.W) or UserInputService:IsKeyDown(Enum.KeyCode.A) or 
                         UserInputService:IsKeyDown(Enum.KeyCode.S) or UserInputService:IsKeyDown(Enum.KeyCode.D)
        if not isMoving then
            root.Velocity = Vector3.new(0, 0, 0)
            if LastSafeCFrame then root.CFrame = LastSafeCFrame end
        else
            if root.Velocity.Magnitude < 100 then LastSafeCFrame = root.CFrame end
        end
    end

    -- Walk on Void
    if WalkOnVoid_Enabled and root then
        if root.Position.Y < Void_Height then
            if not Void_Part then
                Void_Part = Instance.new("Part", workspace)
                Void_Part.Anchored = true
                Void_Part.Size = Vector3.new(2048, 1, 2048)
                Void_Part.Transparency = 1
            end
            Void_Part.CFrame = CFrame.new(root.Position.X, Void_Height - 3.5, root.Position.Z)
        end
    end

    -- FLOAT LOGIC (Låst mark vid hopp)
    if Float_Enabled and root then
        if not Float_Part then
            Float_Part = Instance.new("Part", workspace)
            Float_Part.Anchored = true
            Float_Part.Size = Vector3.new(6, 1, 6)
            Float_Part.Transparency = 1
            -- Låser höjden till där du aktiverade den/första gången
            Float_Height = root.Position.Y - 3.5
        end
        -- Uppdaterar X/Z för att följa fötterna, men behåller låst Y (höjd)
        Float_Part.CFrame = CFrame.new(root.Position.X, Float_Height, root.Position.Z)
    else
        if Float_Part then Float_Part:Destroy() Float_Part = nil end
        Float_Height = nil
    end

    -- Noclip
    if Noclip_Enabled and char then
        for _, v in pairs(char:GetDescendants()) do
            if v:IsA("BasePart") then v.CanCollide = false end
        end
    end

    -- WalkSpeed/JumpPower
    if hum and not Fly_Enabled then
        hum.WalkSpeed = Active_WalkSpeed
        hum.JumpPower = Active_JumpPower
    end

    -- Fly
    if Fly_Enabled and root and hum then
        if not Fly_BodyVelocity then
            Fly_BodyVelocity = Instance.new("BodyVelocity", root)
            Fly_BodyVelocity.MaxForce = Vector3.new(math.huge, math.huge, math.huge)
            Fly_BodyGyro = Instance.new("BodyGyro", root)
            Fly_BodyGyro.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)
            hum.PlatformStand = true
        end
        local flyDirection = hum.MoveDirection
        local verticalMove = Vector3.new(0,0,0)
        if UserInputService:IsKeyDown(Enum.KeyCode.E) then verticalMove = Vector3.new(0, 1, 0)
        elseif UserInputService:IsKeyDown(Enum.KeyCode.Q) then verticalMove = Vector3.new(0, -1, 0) end
        Fly_BodyVelocity.Velocity = (flyDirection + verticalMove).Unit * Fly_Speed
        if (flyDirection + verticalMove).Magnitude == 0 then Fly_BodyVelocity.Velocity = Vector3.new(0,0,0) end
        Fly_BodyGyro.CFrame = CFrame.new(Vector3.new(0,0,0), Camera.CFrame.LookVector * Vector3.new(1,0,1))
    else
        if Fly_BodyVelocity then Fly_BodyVelocity:Destroy() Fly_BodyVelocity = nil end
        if Fly_BodyGyro then Fly_BodyGyro:Destroy() Fly_BodyGyro = nil end
        if hum then hum.PlatformStand = false end
    end

    -- Freecam Movement
    if Freecam_Enabled and Freecam_Part then
        local speed = 2
        local moveVector = Vector3.new(0,0,0)
        if UserInputService:IsKeyDown(Enum.KeyCode.W) then moveVector = moveVector + Camera.CFrame.LookVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.S) then moveVector = moveVector - Camera.CFrame.LookVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.A) then moveVector = moveVector - Camera.CFrame.RightVector end
        if UserInputService:IsKeyDown(Enum.KeyCode.D) then moveVector = moveVector + Camera.CFrame.RightVector end
        Freecam_Part.CFrame = Freecam_Part.CFrame + (moveVector * speed)
        Camera.CameraType = Enum.CameraType.Scriptable
        Camera.CFrame = Freecam_Part.CFrame
    end

    -- Spectate Guard
    if Spectating_Player and Spectating_Player.Character and Spectating_Player.Character:FindFirstChild("Humanoid") then
        Camera.CameraSubject = Spectating_Player.Character.Humanoid
    end

    -- Aimbot FOV Visuals
    FOVCircle.Visible = Aimbot_FOV_Enabled
    FOVCircle.Position = UserInputService:GetMouseLocation()
    FOVCircle.Radius = Aimbot_FOV_Radius
    FOVCircle.Color = Aimbot_FOV_Color

    -- Aimbot Logic
    if Aimbot_Enabled and UserInputService:IsKeyDown(Aimbot_Key) then
        -- Enkel sökning efter närmsta spelare (logik hämtad från originalfil)
        local target = nil
        local shortestDist = Aimbot_FOV_Radius
        for _, p in pairs(Players:GetPlayers()) do
            if p ~= LocalPlayer and p.Character then
                local head = GetHead(p.Character)
                if head then
                    local screenPos, onScreen = Camera:WorldToViewportPoint(head.Position)
                    if onScreen then
                        local dist = (Vector2.new(screenPos.X, screenPos.Y) - UserInputService:GetMouseLocation()).Magnitude
                        if dist < shortestDist then shortestDist = dist target = p end
                    end
                end
            end
        end
        if target and target.Character then
            local head = GetHead(target.Character)
            if head then
                Camera.CFrame = Camera.CFrame:Lerp(CFrame.new(Camera.CFrame.Position, head.Position), 1/Aimbot_Smoothing)
            end
        end
    end

    -- ESP Rendering
    for _, p in pairs(Players:GetPlayers()) do
        if p == LocalPlayer then continue end
        local pchar = p.Character
        if pchar then
            local highlight = pchar:FindFirstChild("UniversalHighlight")
            if ESP_Enabled then
                if not highlight then highlight = Instance.new("Highlight", pchar) highlight.Name = "UniversalHighlight" end
                highlight.Enabled = true
                highlight.FillColor = IsVisible(pchar) and VisibleColor or HiddenColor
            elseif highlight then
                highlight.Enabled = false
            end
        end
    end
end)

Rayfield:Notify({
   Title = "Anti Slap Updated",
   Content = "Movement Lock is now active when not pressing keys.",
   Duration = 3,
   Image = "lock",
})