The All In One Script

--[[
    =============================================================================================================
    PROTOTYPE MENU V62 - THE BEHEMOTH EDITION (PC & MOBILE)
    =============================================================================================================
    Developer: Expert Luau Engineer
    Features: 100% Features Restored, Fully Expanded Code, Zero Compression Macros, Flawless Keybinds.
    Status: Bulletproofed, Error-Handled, and Fully Optimized for Maximum Executor Compatibility.
    =============================================================================================================
]]

print("[Prototype] Initializing Prototype Menu V62...")

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

-- ============================================================================
-- [1] ROBLOX SERVICES
-- ============================================================================
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local TweenService = game:GetService("TweenService")
local Workspace = game:GetService("Workspace")
local Lighting = game:GetService("Lighting")
local CoreGui = game:GetService("CoreGui")
local VirtualInputManager = game:GetService("VirtualInputManager")
local InsertService = game:GetService("InsertService")

local LocalPlayer = Players.LocalPlayer
local Camera = Workspace.CurrentCamera
local Mouse = LocalPlayer:GetMouse()

-- ============================================================================
-- [2] DRAWING API FAILSAFE (FOR MOBILE EXECUTORS)
-- ============================================================================
local hasDrawing = false
pcall(function()
    if type(Drawing) == "table" or type(Drawing) == "userdata" then
        if Drawing.new then 
            hasDrawing = true 
            print("[Prototype] Drawing API is supported.")
        end
    end
end)

-- ============================================================================
-- [3] GLOBAL STATE MANAGEMENT
-- ============================================================================
local State = {
    -- Movement States
    Fly = false,
    Hover = false,
    Freecam = false,
    Speed = false,
    Noclip = false,
    SpiderClimb = false,
    FEHelicopter = false,
    InvGravity = false,
    MoonGravity = false,
    InfJump = false,
    MagicCarpet = false,
    CarFly = false,
    CarSpeedEnabled = false,
    
    -- Visual States
    ESP = false,
    Chams = false,
    Tracers = false,
    TeamCheck = false,
    Fullbright = false,
    XRay = false,
    ShowFOV = false,
    
    -- Combat & Utility States
    Hitbox = false,
    Invisibility = false,
    ClickTP = false,
    BuildMode = false,
    CamLock = false,
    LockBot = false,
    NPCCamLock = false,
    NPCLockBot = false,
    AntiRagdoll = false,
    VoidSaver = false,
    AntiCheatBypass = false,
    Triggerbot = false,
    RandomTP = false,
    KeybindsEnabled = true,
    
    -- Configurations & Sliders
    FlySpeed = 100,
    WalkSpeed = 175,
    FOV = 70,
    CamLockSmoothness = 0.5,
    CamLockFOV = 150,
    TriggerDelay = 0,
    XRayOpacity = 0.5,
    CarSpeed = 100,
    AimPrediction = 0,
    HeadScale = 1,
    BodyWidth = 1,
    BodyHeight = 1,
    RandomTPInterval = 2,
}

-- ============================================================================
-- [4] INTERNAL VARIABLES & CACHES
-- ============================================================================
local Connections = {}
local OriginalTransparencies = {}
local OriginalXRay = {}
local OriginalLighting = {}
local FlyInstances = {}
local SpiderInstances = {}
local CarFlyInstances = {}
local TracerLines = {}
local SpawnedSlabs = {}
local CarpetParts = {}
local CachedNPCs = {}

local FreecamPart = nil
local CamlockTarget = nil
local NPCCamlockTarget = nil
local currentEmote = nil
local FOVCircle = nil

local Toggles = {} -- Stores Rayfield Toggles for Keybind Syncing

local lastDashTime = 0 
local lastBreakTime = 0
local lastTriggerTime = 0
local lastNPCCache = 0
local lastRandomTP = 0

-- Setup FOV Circle if Drawing API is present
if hasDrawing then
    pcall(function()
        FOVCircle = Drawing.new("Circle")
        FOVCircle.Color = Color3.fromRGB(0, 225, 255)
        FOVCircle.Thickness = 1.5
        FOVCircle.Filled = false
        FOVCircle.Transparency = 0.8
        FOVCircle.Visible = false
    end)
end

-- ============================================================================
-- [5] THEME SAVER & RAYFIELD INITIALIZATION
-- ============================================================================
local SavedTheme = "Amethyst"
pcall(function() 
    if isfile and readfile and isfile("PrototypeMenuTheme.txt") then 
        local raw = readfile("PrototypeMenuTheme.txt")
        raw = string.gsub(raw, "%s+", "") -- Remove invisible characters
        local validThemes = {Amethyst=1, Ocean=1, Light=1, Serenity=1, DarkBlue=1, Green=1}
        if validThemes[raw] then 
            SavedTheme = raw 
            print("[Prototype] Loaded saved theme: " .. SavedTheme)
        end
    end 
end)

print("[Prototype] Fetching Rayfield UI Library...")
local successRay, Rayfield = pcall(function() 
    return loadstring(game:HttpGet('https://sirius.menu/rayfield'))() 
end)

if not successRay or type(Rayfield) ~= "table" then
    game.StarterGui:SetCore("SendNotification", {
        Title = "Prototype Error",
        Text = "Failed to load Rayfield UI. Executor might be blocking loadstring.",
        Duration = 10
    })
    warn("[Prototype] Rayfield UI failed to load.")
    return
end
print("[Prototype] Rayfield UI Loaded Successfully.")

-- ============================================================================
-- [6] HELPER FUNCTIONS
-- ============================================================================
local function getRoot(char) 
    return char and char:FindFirstChild("HumanoidRootPart") 
end

local function getVehicleRoot()
    local char = LocalPlayer.Character
    if not char then return nil end
    local hum = char:FindFirstChildOfClass("Humanoid")
    if hum and hum.SeatPart and hum.SeatPart:IsA("VehicleSeat") then
        local vehicle = hum.SeatPart:FindFirstAncestorOfClass("Model")
        if vehicle and vehicle.PrimaryPart then 
            return vehicle.PrimaryPart 
        else 
            return hum.SeatPart 
        end
    end
    return nil
end

local function spawnItemSafe(id, successMsg, customSetup)
    local success, err = pcall(function()
        local objects = game:GetObjects("rbxassetid://" .. tostring(id))
        local item = objects[1]
        if item then
            if item:IsA("Tool") then
                item.Parent = LocalPlayer.Backpack
            else
                local hrp = getRoot(LocalPlayer.Character)
                if hrp then
                    if item:IsA("Model") then 
                        item:PivotTo(hrp.CFrame * CFrame.new(0, 0, -5)) 
                    else 
                        item.CFrame = hrp.CFrame * CFrame.new(0, 0, -5) 
                    end
                end
                item.Parent = Workspace
            end
            if customSetup then customSetup(item) end
            Rayfield:Notify({Title = "Success!", Content = successMsg, Duration = 4})
        end
    end)
    if not success then 
        Rayfield:Notify({Title = "Execution Error", Content = "Your executor blocks game:GetObjects().", Duration = 5}) 
        warn("[Prototype] Item spawn failed: " .. tostring(err))
    end
end

-- ============================================================================
-- [7] MOVEMENT MODULES
-- ============================================================================

local function setupFly(state)
    pcall(function()
        if Connections.Fly then Connections.Fly:Disconnect(); Connections.Fly = nil end
        local char = LocalPlayer.Character
        local hrp = getRoot(char)
        local hum = char and char:FindFirstChildOfClass("Humanoid")
        
        if not hrp or not hum then return end

        if state then
            hum.PlatformStand = true
            local bg = Instance.new("BodyGyro", hrp)
            bg.P = 9e4
            bg.MaxTorque = Vector3.new(9e9, 9e9, 9e9)
            bg.CFrame = hrp.CFrame
            
            local bv = Instance.new("BodyVelocity", hrp)
            bv.Velocity = Vector3.new(0,0,0)
            bv.MaxForce = Vector3.new(9e9, 9e9, 9e9)
            
            FlyInstances.NormalFly = {bg, bv}

            local ControlModule
            pcall(function() ControlModule = require(LocalPlayer.PlayerScripts:WaitForChild("PlayerModule")):GetControls() end)

            Connections.Fly = RunService.RenderStepped:Connect(function()
                local moveVector = Vector3.zero
                if ControlModule then moveVector = ControlModule:GetMoveVector() end
                
                local W = UserInputService:IsKeyDown(Enum.KeyCode.W) and -1 or 0
                local S = UserInputService:IsKeyDown(Enum.KeyCode.S) and 1 or 0
                local A = UserInputService:IsKeyDown(Enum.KeyCode.A) and -1 or 0
                local D = UserInputService:IsKeyDown(Enum.KeyCode.D) and 1 or 0
                if moveVector.Magnitude == 0 then moveVector = Vector3.new(A + D, 0, W + S) end
                
                local camCFrame = Camera.CFrame
                local camDir = camCFrame.LookVector * -moveVector.Z
                local rightDir = camCFrame.RightVector * moveVector.X
                local upDown = (UserInputService:IsKeyDown(Enum.KeyCode.Space) and 1 or 0) + (UserInputService:IsKeyDown(Enum.KeyCode.LeftShift) and -1 or 0)

                local finalDir = (camDir + rightDir + Vector3.new(0, upDown, 0))
                if finalDir.Magnitude > 0 then finalDir = finalDir.Unit end
                
                bv.Velocity = finalDir * State.FlySpeed 
                bg.CFrame = camCFrame
            end)
        else
            if FlyInstances.NormalFly then 
                for _, inst in ipairs(FlyInstances.NormalFly) do if inst and inst.Parent then inst:Destroy() end end
                FlyInstances.NormalFly = nil 
            end
            if hum and not State.FEHelicopter and not State.AntiRagdoll then hum.PlatformStand = false end
        end
    end)
end

local function executeDash()
    if tick() - lastDashTime < 3.5 then return end 
    local char = LocalPlayer.Character
    local hrp = getRoot(char)
    if not hrp then return end

    lastDashTime = tick()
    local moveDir = hrp.CFrame.LookVector
    
    pcall(function()
        local ControlModule = require(LocalPlayer.PlayerScripts:WaitForChild("PlayerModule")):GetControls()
        local mv = ControlModule:GetMoveVector()
        if mv.Magnitude > 0 then moveDir = (Camera.CFrame.RightVector * mv.X + Camera.CFrame.LookVector * -mv.Z).Unit end
    end)
    
    local flatDir = Vector3.new(moveDir.X, 0, moveDir.Z)
    if flatDir.Magnitude > 0 then flatDir = flatDir.Unit end

    local dashVel = Instance.new("BodyVelocity")
    dashVel.Name = "PrototypeDash"
    dashVel.MaxForce = Vector3.new(9e9, 0, 9e9)
    dashVel.Velocity = flatDir * 150
    dashVel.Parent = hrp
    
    task.delay(0.2, function() if dashVel and dashVel.Parent then dashVel:Destroy() end end)
end

UserInputService.JumpRequest:Connect(function()
    if State.InfJump and LocalPlayer.Character then
        local hrp = LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
        local hum = LocalPlayer.Character:FindFirstChildOfClass("Humanoid")
        if hrp and hum then
            hum:ChangeState(Enum.HumanoidStateType.Jumping)
            local jumpPower = (hum.UseJumpPower and hum.JumpPower) or 50
            if not hum.UseJumpPower then jumpPower = math.sqrt(2 * Workspace.Gravity * hum.JumpHeight) end
            if jumpPower == 0 or jumpPower ~= jumpPower then jumpPower = 50 end
            hrp.AssemblyLinearVelocity = Vector3.new(hrp.AssemblyLinearVelocity.X, jumpPower, hrp.AssemblyLinearVelocity.Z)
        end
    end
end)

local function setupFreecam(state)
    pcall(function()
        if Connections.Freecam then Connections.Freecam:Disconnect(); Connections.Freecam = nil end
        local char = LocalPlayer.Character
        local hrp = getRoot(char)
        local hum = char and char:FindFirstChildOfClass("Humanoid")
        
        if state then
            if hrp then hrp.Anchored = true end 
            FreecamPart = Instance.new("Part", Workspace)
            FreecamPart.Name = "PrototypeFreecam"
            FreecamPart.Size = Vector3.new(1,1,1)
            FreecamPart.Transparency = 1
            FreecamPart.CanCollide = false
            FreecamPart.Anchored = false
            FreecamPart.CFrame = Camera.CFrame
            
            local bg = Instance.new("BodyGyro", FreecamPart)
            bg.P = 9e4
            bg.MaxTorque = Vector3.new(9e9, 9e9, 9e9)
            bg.CFrame = FreecamPart.CFrame
            
            local bv = Instance.new("BodyVelocity", FreecamPart)
            bv.Velocity = Vector3.new(0,0,0)
            bv.MaxForce = Vector3.new(9e9, 9e9, 9e9)
            Camera.CameraSubject = FreecamPart

            local ControlModule
            pcall(function() ControlModule = require(LocalPlayer.PlayerScripts:WaitForChild("PlayerModule")):GetControls() end)

            Connections.Freecam = RunService.RenderStepped:Connect(function()
                local moveVector = Vector3.zero
                if ControlModule then moveVector = ControlModule:GetMoveVector() end
                
                local W = UserInputService:IsKeyDown(Enum.KeyCode.W) and -1 or 0
                local S = UserInputService:IsKeyDown(Enum.KeyCode.S) and 1 or 0
                local A = UserInputService:IsKeyDown(Enum.KeyCode.A) and -1 or 0
                local D = UserInputService:IsKeyDown(Enum.KeyCode.D) and 1 or 0
                if moveVector.Magnitude == 0 then moveVector = Vector3.new(A + D, 0, W + S) end
                
                local camCFrame = Camera.CFrame
                local camDir = camCFrame.LookVector * -moveVector.Z
                local rightDir = camCFrame.RightVector * moveVector.X
                local upDown = (UserInputService:IsKeyDown(Enum.KeyCode.Space) and 1 or 0) + (UserInputService:IsKeyDown(Enum.KeyCode.LeftShift) and -1 or 0)

                local finalDir = (camDir + rightDir + Vector3.new(0, upDown, 0))
                if finalDir.Magnitude > 0 then finalDir = finalDir.Unit end
                
                bv.Velocity = finalDir * State.FlySpeed 
                bg.CFrame = camCFrame
            end)
        else
            if FreecamPart then FreecamPart:Destroy(); FreecamPart = nil end
            if hrp then hrp.Anchored = false end
            if hum then Camera.CameraSubject = hum end
        end
    end)
end

local function executeFreecamTP()
    if State.Freecam then
        local hrp = getRoot(LocalPlayer.Character)
        if hrp and FreecamPart then 
            hrp.Anchored = false
            hrp.CFrame = FreecamPart.CFrame
            if Toggles.Freecam then Toggles.Freecam:Set(false) end 
        end
    end
end

local function setupHover(state)
    if Connections.Hover then Connections.Hover:Disconnect(); Connections.Hover = nil end
    local char = LocalPlayer.Character
    local hrp = getRoot(char)
    if not hrp then return end
    
    if hrp:FindFirstChild("PrototypeHoverVel") then hrp.PrototypeHoverVel:Destroy() end

    if state then
        local bv = Instance.new("BodyVelocity", hrp)
        bv.Name = "PrototypeHoverVel"
        bv.MaxForce = Vector3.new(0, 9e9, 0)
        bv.Velocity = Vector3.new(0, 0, 0)
        
        Connections.Hover = RunService.Stepped:Connect(function()
            local hum = char:FindFirstChild("Humanoid")
            if hum and hum:GetState() == Enum.HumanoidStateType.Freefall then 
                hum:ChangeState(Enum.HumanoidStateType.Running) 
            end
        end)
    end
end

local function setupInvGravity(state)
    if Connections.InvGravity then Connections.InvGravity:Disconnect(); Connections.InvGravity = nil end
    local char = LocalPlayer.Character
    local hrp = getRoot(char)
    if not hrp then return end
    
    if hrp:FindFirstChild("PrototypeInvGravBF") then hrp.PrototypeInvGravBF:Destroy() end
    if hrp:FindFirstChild("PrototypeInvGravBG") then hrp.PrototypeInvGravBG:Destroy() end

    if state then
        local bf = Instance.new("BodyForce", hrp)
        bf.Name = "PrototypeInvGravBF"
        local bg = Instance.new("BodyGyro", hrp)
        bg.Name = "PrototypeInvGravBG"
        bg.MaxTorque = Vector3.new(9e9, 9e9, 9e9)
        bg.P = 3000
        
        Connections.InvGravity = RunService.RenderStepped:Connect(function()
            if char and getRoot(char) then
                local currentHrp = getRoot(char)
                local totalMass = 0
                for _, part in pairs(char:GetDescendants()) do 
                    if part:IsA("BasePart") then totalMass = totalMass + part.Mass end 
                end
                bf.Force = Vector3.new(0, totalMass * Workspace.Gravity * 2, 0)
                local look = Camera.CFrame.LookVector
                local flatLook = Vector3.new(look.X, 0, look.Z).Unit
                if flatLook.Magnitude > 0 then 
                    bg.CFrame = CFrame.lookAt(currentHrp.Position, currentHrp.Position + flatLook) * CFrame.Angles(0, 0, math.pi) 
                end
            end
        end)
    end
end

local function setupSpeed(state)
    if Connections.Speed then Connections.Speed:Disconnect(); Connections.Speed = nil end
    if state then
        Connections.Speed = RunService.Stepped:Connect(function()
            if LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("Humanoid") then 
                LocalPlayer.Character.Humanoid.WalkSpeed = State.WalkSpeed 
            end
        end)
    else
        if LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("Humanoid") then 
            LocalPlayer.Character.Humanoid.WalkSpeed = 16 
        end
    end
end

local function setupNoclip(state)
    if Connections.Noclip then Connections.Noclip:Disconnect(); Connections.Noclip = nil end
    if state then
        Connections.Noclip = RunService.Stepped:Connect(function()
            if LocalPlayer.Character then
                for _, part in pairs(LocalPlayer.Character:GetDescendants()) do 
                    if part:IsA("BasePart") and part.CanCollide then part.CanCollide = false end 
                end
            end
        end)
    end
end

-- ============================================================================
-- [8] VEHICLE & PHYSICS MODULES
-- ============================================================================
local function setupCarFly(state)
    pcall(function()
        if Connections.CarFly then Connections.CarFly:Disconnect(); Connections.CarFly = nil end
        local vRoot = getVehicleRoot()
        
        if state and vRoot then
            local bg = Instance.new("BodyGyro", vRoot); bg.P = 9e4; bg.MaxTorque = Vector3.new(9e9, 9e9, 9e9); bg.CFrame = vRoot.CFrame
            local bv = Instance.new("BodyVelocity", vRoot); bv.Velocity = Vector3.new(0,0,0); bv.MaxForce = Vector3.new(9e9, 9e9, 9e9)
            CarFlyInstances = {bg, bv}

            local ControlModule
            pcall(function() ControlModule = require(LocalPlayer.PlayerScripts:WaitForChild("PlayerModule")):GetControls() end)

            Connections.CarFly = RunService.RenderStepped:Connect(function()
                local moveVector = Vector3.zero
                if ControlModule then moveVector = ControlModule:GetMoveVector() end
                
                local W = UserInputService:IsKeyDown(Enum.KeyCode.W) and -1 or 0
                local S = UserInputService:IsKeyDown(Enum.KeyCode.S) and 1 or 0
                local A = UserInputService:IsKeyDown(Enum.KeyCode.A) and -1 or 0
                local D = UserInputService:IsKeyDown(Enum.KeyCode.D) and 1 or 0
                if moveVector.Magnitude == 0 then moveVector = Vector3.new(A + D, 0, W + S) end
                
                local camCFrame = Camera.CFrame
                local camDir = camCFrame.LookVector * -moveVector.Z
                local rightDir = camCFrame.RightVector * moveVector.X
                local upDown = (UserInputService:IsKeyDown(Enum.KeyCode.Space) and 1 or 0) + (UserInputService:IsKeyDown(Enum.KeyCode.LeftShift) and -1 or 0)
                
                local finalDir = (camDir + rightDir + Vector3.new(0, upDown, 0))
                if finalDir.Magnitude > 0 then finalDir = finalDir.Unit end
                
                bv.Velocity = finalDir * State.FlySpeed 
                bg.CFrame = CFrame.new(vRoot.Position, vRoot.Position + camCFrame.LookVector)
            end)
        else
            for _, inst in ipairs(CarFlyInstances) do if inst and inst.Parent then inst:Destroy() end end
            CarFlyInstances = {}
            if state and not vRoot then 
                Rayfield:Notify({Title = "Car Fly", Content = "You must be in a Driver Seat!", Duration = 3})
                if Toggles.CarFly then Toggles.CarFly:Set(false) end 
            end
        end
    end)
end

local function setupCarSpeed(state)
    if Connections.CarSpeed then Connections.CarSpeed:Disconnect(); Connections.CarSpeed = nil end
    if state then
        Connections.CarSpeed = RunService.Heartbeat:Connect(function()
            local vRoot = getVehicleRoot()
            if vRoot and UserInputService:IsKeyDown(Enum.KeyCode.W) then
                vRoot.AssemblyLinearVelocity = vRoot.AssemblyLinearVelocity + (vRoot.CFrame.LookVector * (State.CarSpeed * 0.05))
            end
        end)
    end
end

local function setupMagicCarpet(state)
    if Connections.MagicCarpet then Connections.MagicCarpet:Disconnect(); Connections.MagicCarpet = nil end
    for _, p in pairs(CarpetParts) do if p then p:Destroy() end end
    CarpetParts = {}

    if state then
        Connections.MagicCarpet = RunService.Heartbeat:Connect(function()
            local char = LocalPlayer.Character
            local hrp = getRoot(char)
            if not hrp then return end

            if #CarpetParts > 3 then
                local oldPart = table.remove(CarpetParts, 1)
                if oldPart then oldPart:Destroy() end
            end

            local p = Instance.new("Part")
            p.Size = Vector3.new(4, 0.5, 4)
            p.CFrame = hrp.CFrame * CFrame.new(0, -3.2, 0)
            p.Anchored = true
            p.Transparency = 1
            p.CanCollide = true
            p.Parent = Workspace
            table.insert(CarpetParts, p)
        end)
    end
end

local function setupSpiderClimb(state)
    if Connections.SpiderClimb then Connections.SpiderClimb:Disconnect(); Connections.SpiderClimb = nil end
    local char = LocalPlayer.Character
    local hrp = getRoot(char)
    if not hrp then return end

    if state then
        local bg = Instance.new("BodyGyro", hrp); bg.P = 100000; bg.MaxTorque = Vector3.zero
        local bv = Instance.new("BodyVelocity", hrp); bv.MaxForce = Vector3.zero; bv.Velocity = Vector3.zero
        SpiderInstances = {bg, bv}

        Connections.SpiderClimb = RunService.RenderStepped:Connect(function()
            local currentHrp = getRoot(LocalPlayer.Character)
            if not currentHrp then return end

            local rayOrigin = currentHrp.Position
            local rayDirection = currentHrp.CFrame.LookVector * 2.5
            local rayParams = RaycastParams.new()
            rayParams.FilterDescendantsInstances = {LocalPlayer.Character, Camera}
            rayParams.FilterType = Enum.RaycastFilterType.Exclude

            local hit = Workspace:Raycast(rayOrigin, rayDirection, rayParams)
            local W = UserInputService:IsKeyDown(Enum.KeyCode.W)

            if hit and W then
                bg.MaxTorque = Vector3.new(9e9, 9e9, 9e9)
                bv.MaxForce = Vector3.new(9e9, 9e9, 9e9)
                bg.CFrame = CFrame.lookAt(currentHrp.Position, currentHrp.Position - hit.Normal) * CFrame.Angles(math.rad(80), 0, 0)
                bv.Velocity = Vector3.new(0, State.WalkSpeed * 0.4, 0) 
            else
                bg.MaxTorque = Vector3.zero
                bv.MaxForce = Vector3.zero
            end
        end)
    else
        for _, inst in ipairs(SpiderInstances) do if inst and inst.Parent then inst:Destroy() end end
        SpiderInstances = {}
    end
end

local function setupMoonGravity(state)
    if Connections.MoonGravity then Connections.MoonGravity:Disconnect(); Connections.MoonGravity = nil end
    local char = LocalPlayer.Character
    local hrp = getRoot(char)
    if not hrp then return end
    
    if hrp:FindFirstChild("PrototypeMoonGrav") then hrp.PrototypeMoonGrav:Destroy() end

    if state then
        local bf = Instance.new("BodyForce", hrp)
        bf.Name = "PrototypeMoonGrav"
        Connections.MoonGravity = RunService.RenderStepped:Connect(function()
            if char and getRoot(char) then
                local totalMass = 0
                for _, part in pairs(char:GetDescendants()) do 
                    if part:IsA("BasePart") then totalMass = totalMass + part.Mass end 
                end
                bf.Force = Vector3.new(0, totalMass * Workspace.Gravity * 0.85, 0)
            end
        end)
    end
end

local function setupVoidSaver(state)
    if Connections.VoidSaver then Connections.VoidSaver:Disconnect(); Connections.VoidSaver = nil end
    if state then
        local lastSafePos = CFrame.new(0, 50, 0)
        Connections.VoidSaver = RunService.Stepped:Connect(function()
            local char = LocalPlayer.Character
            local hrp = getRoot(char)
            local hum = char and char:FindFirstChildOfClass("Humanoid")
            if not hrp or not hum then return end
            
            if hum.FloorMaterial ~= Enum.Material.Air and hum:GetState() ~= Enum.HumanoidStateType.Freefall then 
                lastSafePos = hrp.CFrame 
            end
            
            if hrp.Position.Y < (Workspace.FallenPartsDestroyHeight + 50) then
                hrp.AssemblyLinearVelocity = Vector3.zero
                hrp.CFrame = lastSafePos + Vector3.new(0, 5, 0)
                Rayfield:Notify({Title = "Void Saver", Content = "Saved from falling into the void!", Duration = 2})
            end
        end)
    end
end

local function setupAntiCheatBypass(state)
    if Connections.AntiCheatBypass then Connections.AntiCheatBypass:Disconnect(); Connections.AntiCheatBypass = nil end
    if state then
        Connections.AntiCheatBypass = RunService.Heartbeat:Connect(function()
            local char = LocalPlayer.Character
            local hrp = getRoot(char)
            if hrp and (State.Fly or State.Speed or State.Hover or State.Freecam or State.CarFly) then
                local realVel = hrp.Velocity
                hrp.Velocity = Vector3.new(0, 0, 0)
                RunService.RenderStepped:Wait()
                hrp.Velocity = realVel
            end
        end)
    end
end

-- ============================================================================
-- [9] AIMBOT & TRIGGERBOT MODULES
-- ============================================================================
local function isVisible(targetPart)
    local origin = Camera.CFrame.Position
    local direction = targetPart.Position - origin
    local params = RaycastParams.new()
    params.FilterDescendantsInstances = {LocalPlayer.Character, targetPart.Parent}
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.IgnoreWater = true
    local hit = Workspace:Raycast(origin, direction, params)
    return not hit 
end

local function getCachedNPCs()
    if tick() - lastNPCCache > 1 then
        lastNPCCache = tick()
        table.clear(CachedNPCs)
        for _, obj in pairs(Workspace:GetDescendants()) do
            if obj:IsA("Model") and obj ~= LocalPlayer.Character and not Players:GetPlayerFromCharacter(obj) then
                local hum = obj:FindFirstChildOfClass("Humanoid")
                if hum and hum.Health > 0 and (obj:FindFirstChild("Head") or obj:FindFirstChild("HumanoidRootPart")) then
                    table.insert(CachedNPCs, obj)
                end
            end
        end
    end
    return CachedNPCs
end

local function getAimbotTarget(isNPC, is360)
    local bestTarget = nil
    local shortestDist = is360 and math.huge or State.CamLockFOV
    local center = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)
    local localHrp = getRoot(LocalPlayer.Character)
    if is360 and not localHrp then return nil end

    local targets = {}
    if isNPC then
        for _, obj in pairs(getCachedNPCs()) do table.insert(targets, {char = obj, isPlayer = false}) end
    else
        for _, p in pairs(Players:GetPlayers()) do
            if p ~= LocalPlayer and p.Character then table.insert(targets, {char = p.Character, isPlayer = true, p = p}) end
        end
    end

    for _, data in pairs(targets) do
        if data.isPlayer and State.TeamCheck and LocalPlayer.Team and data.p.Team == LocalPlayer.Team then continue end
        local char = data.char
        local head = char:FindFirstChild("Head") or char:FindFirstChild("HumanoidRootPart")
        local hum = char:FindFirstChildOfClass("Humanoid")
        
        if head and hum and hum.Health > 0 and isVisible(head) then
            if is360 then
                local dist = (localHrp.Position - head.Position).Magnitude
                if dist < shortestDist then 
                    shortestDist = dist
                    bestTarget = char 
                end
            else
                local screenPos, onScreen = Camera:WorldToViewportPoint(head.Position)
                if onScreen then
                    local dist = (Vector2.new(screenPos.X, screenPos.Y) - center).Magnitude
                    if dist < shortestDist then 
                        shortestDist = dist
                        bestTarget = char 
                    end
                end
            end
        end
    end
    return bestTarget
end

local function setupMasterAimbot()
    if Connections.MasterAimbot then Connections.MasterAimbot:Disconnect(); Connections.MasterAimbot = nil end

    if State.CamLock or State.LockBot or State.NPCCamLock or State.NPCLockBot then
        Connections.MasterAimbot = RunService.RenderStepped:Connect(function()
            if State.Freecam then return end 

            -- Breakaway logic
            if tick() - lastBreakTime > 0.5 then
                local delta = UserInputService:GetMouseDelta()
                if delta.Magnitude > 35 then 
                    CamlockTarget = nil
                    NPCCamlockTarget = nil
                    lastBreakTime = tick()
                    return
                end
            else return end

            local function validateTarget(t) 
                return t and (t:FindFirstChild("Head") or t:FindFirstChild("HumanoidRootPart")) and t:FindFirstChildOfClass("Humanoid") and t:FindFirstChildOfClass("Humanoid").Health > 0 and isVisible(t:FindFirstChild("Head") or t:FindFirstChild("HumanoidRootPart")) 
            end

            -- Process Player Aim
            if State.CamLock or State.LockBot then
                if not validateTarget(CamlockTarget) then CamlockTarget = getAimbotTarget(false, State.LockBot) end
                if CamlockTarget then
                    local head = CamlockTarget:FindFirstChild("Head") or CamlockTarget:FindFirstChild("HumanoidRootPart")
                    local hrp = getRoot(CamlockTarget)
                    local predictedPos = head.Position
                    if hrp and State.AimPrediction > 0 then predictedPos = head.Position + (hrp.Velocity * (State.AimPrediction * 0.05)) end
                    Camera.CFrame = Camera.CFrame:Lerp(CFrame.new(Camera.CFrame.Position, predictedPos), State.CamLockSmoothness)
                end
            end

            -- Process NPC Aim
            if State.NPCCamLock or State.NPCLockBot then
                if not validateTarget(NPCCamlockTarget) then NPCCamlockTarget = getAimbotTarget(true, State.NPCLockBot) end
                if NPCCamlockTarget then
                    local head = NPCCamlockTarget:FindFirstChild("Head") or NPCCamlockTarget:FindFirstChild("HumanoidRootPart")
                    local hrp = getRoot(NPCCamlockTarget)
                    local predictedPos = head.Position
                    if hrp and State.AimPrediction > 0 then predictedPos = head.Position + (hrp.Velocity * (State.AimPrediction * 0.05)) end
                    Camera.CFrame = Camera.CFrame:Lerp(CFrame.new(Camera.CFrame.Position, predictedPos), State.CamLockSmoothness)
                end
            end

            -- Manage Visualizer
            if FOVCircle then
                FOVCircle.Position = Vector2.new(Camera.ViewportSize.X/2, Camera.ViewportSize.Y/2)
                FOVCircle.Radius = State.CamLockFOV
                FOVCircle.Visible = State.ShowFOV and not (State.LockBot or State.NPCLockBot)
            end
        end)
    else
        CamlockTarget = nil
        NPCCamlockTarget = nil
        if FOVCircle then FOVCircle.Visible = false end
    end
end

local function performTriggerClick()
    if mouse1press and mouse1release then
        pcall(function() mouse1press(); task.delay(0.05, mouse1release) end)
        return
    end
    local char = LocalPlayer.Character
    if char then
        local tool = char:FindFirstChildOfClass("Tool")
        if tool then
            pcall(function() tool:Activate(); task.delay(0.05, function() tool:Deactivate() end) end)
            return
        end
    end
    pcall(function()
        VirtualInputManager:SendMouseButtonEvent(0, 0, 0, true, game, 1)
        task.delay(0.05, function() VirtualInputManager:SendMouseButtonEvent(0, 0, 0, false, game, 1) end)
    end)
end

local function setupTriggerbot(state)
    if Connections.Triggerbot then Connections.Triggerbot:Disconnect(); Connections.Triggerbot = nil end
    if state then
        Connections.Triggerbot = RunService.RenderStepped:Connect(function()
            local rayOrigin = Camera.CFrame.Position
            local rayDirection = Camera.CFrame.LookVector * 1000
            local rayParams = RaycastParams.new()
            rayParams.FilterDescendantsInstances = {LocalPlayer.Character, Camera}
            rayParams.FilterType = Enum.RaycastFilterType.Exclude
            rayParams.IgnoreWater = true

            local hit = Workspace:Raycast(rayOrigin, rayDirection, rayParams)
            if hit and hit.Instance then
                local targetChar = hit.Instance:FindFirstAncestorOfClass("Model")
                if targetChar and targetChar:FindFirstChild("Humanoid") and targetChar.Humanoid.Health > 0 then
                    local targetPlayer = Players:GetPlayerFromCharacter(targetChar)
                    if targetPlayer and targetPlayer ~= LocalPlayer then
                        if State.TeamCheck and LocalPlayer.Team and targetPlayer.Team == LocalPlayer.Team then return end
                        if tick() - lastTriggerTime >= State.TriggerDelay then
                            lastTriggerTime = tick()
                            performTriggerClick() 
                        end
                    elseif not targetPlayer then
                        -- Allow triggering on NPCs
                        if tick() - lastTriggerTime >= State.TriggerDelay then
                            lastTriggerTime = tick()
                            performTriggerClick() 
                        end
                    end
                end
            end
        end)
    end
end

local function setupRandomTP(state)
    if Connections.RandomTP then Connections.RandomTP:Disconnect(); Connections.RandomTP = nil end
    if state then
        Connections.RandomTP = RunService.Heartbeat:Connect(function()
            if tick() - lastRandomTP >= State.RandomTPInterval then
                lastRandomTP = tick()
                local valid = {}
                for _, p in pairs(Players:GetPlayers()) do
                    if p ~= LocalPlayer and p.Character and getRoot(p.Character) and p.Character:FindFirstChild("Humanoid") and p.Character.Humanoid.Health > 0 then
                        if not (State.TeamCheck and LocalPlayer.Team and p.Team == LocalPlayer.Team) then 
                            table.insert(valid, p) 
                        end
                    end
                end
                if #valid > 0 then
                    local target = valid[math.random(1, #valid)]
                    local tHrp = getRoot(target.Character)
                    local myHrp = getRoot(LocalPlayer.Character)
                    if tHrp and myHrp then 
                        myHrp.CFrame = tHrp.CFrame * CFrame.new(0, 0, 3)
                        Rayfield:Notify({Title = "Assassin", Content = "Teleported behind " .. target.Name, Duration = 2}) 
                    end
                end
            end
        end)
    end
end

local function setupHitbox(state)
    if Connections.Hitbox then Connections.Hitbox:Disconnect(); Connections.Hitbox = nil end
    if state then
        Connections.Hitbox = RunService.Stepped:Connect(function()
            for _, player in pairs(Players:GetPlayers()) do
                if State.TeamCheck and LocalPlayer.Team and player.Team == LocalPlayer.Team then continue end
                if player ~= LocalPlayer and player.Character then
                    local hrp = getRoot(player.Character)
                    if hrp then 
                        hrp.Size = Vector3.new(18, 18, 18)
                        hrp.Transparency = 0.7
                        hrp.CanCollide = false 
                    end
                end
            end
        end)
    else
        for _, player in pairs(Players:GetPlayers()) do
            if player ~= LocalPlayer and player.Character then
                local hrp = getRoot(player.Character)
                if hrp then 
                    hrp.Size = Vector3.new(2, 2, 1)
                    hrp.Transparency = 1 
                end
            end
        end
    end
end

-- ============================================================================
-- [10] VISUALS MODULE (ESP, Tracers, Chams, XRay, Fullbright)
-- ============================================================================
local function clearESP()
    for _, player in pairs(Players:GetPlayers()) do
        if player.Character then
            if player.Character:FindFirstChild("PrototypeESP_HL") then player.Character.PrototypeESP_HL:Destroy() end
            if player.Character:FindFirstChild("PrototypeESP_BB") then player.Character.PrototypeESP_BB:Destroy() end
        end
    end
end

local function setupESP(state)
    if Connections.ESP then Connections.ESP:Disconnect(); Connections.ESP = nil end
    clearESP()

    if state then
        Connections.ESP = RunService.RenderStepped:Connect(function()
            local localHrp = getRoot(LocalPlayer.Character)
            for _, player in pairs(Players:GetPlayers()) do
                if player ~= LocalPlayer and player.Character then
                    local targetHrp = getRoot(player.Character)
                    local char = player.Character
                    local isEnemy = true
                    if State.TeamCheck and LocalPlayer.Team and player.Team == LocalPlayer.Team then isEnemy = false end

                    if targetHrp and isEnemy then
                        if not char:FindFirstChild("PrototypeESP_HL") then
                            local hl = Instance.new("Highlight", char)
                            hl.Name = "PrototypeESP_HL"
                            hl.FillColor = Color3.fromRGB(0, 225, 255)
                            hl.FillTransparency = 0.5
                            hl.OutlineColor = Color3.fromRGB(255, 0, 127)
                            
                            local bb = Instance.new("BillboardGui", char)
                            bb.Name = "PrototypeESP_BB"
                            bb.Size = UDim2.new(0, 200, 0, 50)
                            bb.StudsOffset = Vector3.new(0, 3, 0)
                            bb.AlwaysOnTop = true
                            
                            local txt = Instance.new("TextLabel", bb)
                            txt.Name = "NameLabel"
                            txt.Size = UDim2.new(1,0,1,0)
                            txt.BackgroundTransparency = 1
                            txt.TextColor3 = Color3.new(1,1,1)
                            txt.Font = Enum.Font.GothamBold
                            txt.TextSize = 14
                        end
                        local bb = char:FindFirstChild("PrototypeESP_BB")
                        if bb and localHrp then
                            local label = bb:FindFirstChild("NameLabel")
                            if label then label.Text = string.format("%s [%dm]", player.Name, math.floor((localHrp.Position - targetHrp.Position).Magnitude * 0.28)) end
                        end
                    else
                        if char:FindFirstChild("PrototypeESP_HL") then char.PrototypeESP_HL:Destroy() end
                        if char:FindFirstChild("PrototypeESP_BB") then char.PrototypeESP_BB:Destroy() end
                    end
                end
            end
        end)
    end
end

local function setupTracers(state)
    if Connections.Tracers then Connections.Tracers:Disconnect(); Connections.Tracers = nil end
    for _, line in pairs(TracerLines) do pcall(function() line:Remove() end) end
    TracerLines = {}

    if state and not hasDrawing then
        Rayfield:Notify({Title = "Error", Content = "Your executor does not support Tracers.", Duration = 5})
        if Toggles.Tracers then Toggles.Tracers:Set(false) end
        return
    end

    if state then
        Connections.Tracers = RunService.RenderStepped:Connect(function()
            local localHrp = getRoot(LocalPlayer.Character)
            for _, player in pairs(Players:GetPlayers()) do
                if player ~= LocalPlayer then
                    if not TracerLines[player] then
                        pcall(function()
                            TracerLines[player] = Drawing.new("Line")
                            TracerLines[player].Thickness = 2
                            TracerLines[player].Color = Color3.fromRGB(255, 0, 127)
                            TracerLines[player].Transparency = 1
                        end)
                    end
                    local line = TracerLines[player]
                    if not line then continue end

                    local isEnemy = true
                    if State.TeamCheck and LocalPlayer.Team and player.Team == LocalPlayer.Team then isEnemy = false end
                    local targetHrp = getRoot(player.Character)
                    local hum = player.Character and player.Character:FindFirstChild("Humanoid")

                    if targetHrp and hum and hum.Health > 0 and isEnemy and localHrp then
                        local vector, onScreen = Camera:WorldToViewportPoint(targetHrp.Position - Vector3.new(0, 3, 0))
                        if onScreen then
                            line.From = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y)
                            line.To = Vector2.new(vector.X, vector.Y)
                            line.Visible = true
                        else 
                            line.Visible = false 
                        end
                    else 
                        line.Visible = false 
                    end
                end
            end
        end)
    end
end

local function setupChams(state)
    if Connections.Chams then Connections.Chams:Disconnect(); Connections.Chams = nil end
    for _, player in pairs(Players:GetPlayers()) do
        if player.Character and player.Character:FindFirstChild("PrototypeChams") then 
            player.Character.PrototypeChams:Destroy() 
        end
    end

    if state then
        Connections.Chams = RunService.RenderStepped:Connect(function()
            for _, player in pairs(Players:GetPlayers()) do
                if player ~= LocalPlayer and player.Character then
                    local isEnemy = true
                    if State.TeamCheck and LocalPlayer.Team and player.Team == LocalPlayer.Team then isEnemy = false end
                    if isEnemy and getRoot(player.Character) then
                        if not player.Character:FindFirstChild("PrototypeChams") then
                            local hl = Instance.new("Highlight", player.Character)
                            hl.Name = "PrototypeChams"
                            hl.FillColor = Color3.fromRGB(255, 0, 0)
                            hl.FillTransparency = 0.2
                            hl.OutlineTransparency = 1
                            hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
                        end
                    else
                        if player.Character:FindFirstChild("PrototypeChams") then 
                            player.Character.PrototypeChams:Destroy() 
                        end
                    end
                end
            end
        end)
    end
end

local function setupXRay(state)
    if Connections.XRayAdded then Connections.XRayAdded:Disconnect(); Connections.XRayAdded = nil end
    local function applyXRay(p)
        if p:IsA("BasePart") and not p:IsDescendantOf(LocalPlayer.Character) and not p:IsDescendantOf(Camera) then
            if not string.find(p.Name, "Prototype") and not string.find(p.Name, "Gemini") then
                if OriginalXRay[p] == nil then OriginalXRay[p] = p.Transparency end
                if OriginalXRay[p] < 1 then p.Transparency = State.XRayOpacity end
            end
        end
    end

    if state then
        task.spawn(function()
            local descendants = Workspace:GetDescendants()
            for i, v in ipairs(descendants) do
                if i % 2000 == 0 then RunService.RenderStepped:Wait() end
                if not State.XRay then break end
                applyXRay(v)
            end
        end)
        Connections.XRayAdded = Workspace.DescendantAdded:Connect(function(v) 
            task.wait(0.1)
            if State.XRay then applyXRay(v) end 
        end)
    else
        for p, trans in pairs(OriginalXRay) do 
            pcall(function() if p and p.Parent then p.Transparency = trans end end) 
        end
        OriginalXRay = {}
    end
end

local function setupFullbright(state)
    if Connections.Fullbright then Connections.Fullbright:Disconnect(); Connections.Fullbright = nil end

    if state then
        OriginalLighting.Ambient = Lighting.Ambient
        OriginalLighting.OutdoorAmbient = Lighting.OutdoorAmbient
        OriginalLighting.Brightness = Lighting.Brightness
        OriginalLighting.ClockTime = Lighting.ClockTime
        OriginalLighting.FogEnd = Lighting.FogEnd
        OriginalLighting.GlobalShadows = Lighting.GlobalShadows
        pcall(function() OriginalLighting.ColorShift_Bottom = Lighting.ColorShift_Bottom; OriginalLighting.ColorShift_Top = Lighting.ColorShift_Top end)

        Connections.Fullbright = RunService.RenderStepped:Connect(function()
            Lighting.Ambient = Color3.new(1, 1, 1)
            Lighting.OutdoorAmbient = Color3.new(1, 1, 1)
            pcall(function() Lighting.ColorShift_Bottom = Color3.new(1, 1, 1); Lighting.ColorShift_Top = Color3.new(1, 1, 1) end)
            Lighting.Brightness = 2
            Lighting.ClockTime = 14
            Lighting.FogEnd = 100000
            Lighting.GlobalShadows = false
        end)
    else
        for prop, val in pairs(OriginalLighting) do pcall(function() Lighting[prop] = val end) end
        OriginalLighting = {}
    end
end

-- FOV Changer
Connections.FOV = RunService.RenderStepped:Connect(function()
    if Camera.FieldOfView ~= State.FOV then 
        pcall(function() Camera.FieldOfView = State.FOV end) 
    end
end)

-- ============================================================================
-- [11] UTILITY MODULES (Tools & Commands)
-- ============================================================================
local function setupBuildMode(state)
    if Connections.BuildMode then Connections.BuildMode:Disconnect(); Connections.BuildMode = nil end
    if state then
        Connections.BuildMode = UserInputService.InputBegan:Connect(function(input, gpe)
            if gpe then return end 
            if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
                if Mouse.Hit then
                    local slab = Instance.new("Part", Workspace)
                    slab.Name = "PrototypeSlab"
                    slab.Size = Vector3.new(10, 1, 10)
                    slab.CFrame = CFrame.new(Mouse.Hit.Position)
                    slab.Anchored = true
                    slab.Color = Color3.fromRGB(0, 225, 255)
                    slab.Material = Enum.Material.Neon
                    slab.Transparency = 0.3
                    table.insert(SpawnedSlabs, slab)
                end
            end
        end)
    end
end

local function undoSlab()
    if #SpawnedSlabs > 0 then
        local lastSlab = table.remove(SpawnedSlabs, #SpawnedSlabs)
        if lastSlab and lastSlab.Parent then lastSlab:Destroy() end
    end
end

local function setupInvis(state)
    local char = LocalPlayer.Character
    if not char then return end
    if state then
        for _, part in pairs(char:GetDescendants()) do
            if (part:IsA("BasePart") or part:IsA("Decal")) and part.Name ~= "HumanoidRootPart" then
                OriginalTransparencies[part] = part.Transparency
                part.Transparency = 1
            end
        end
    else
        for part, trans in pairs(OriginalTransparencies) do
            if part and part.Parent then part.Transparency = trans end
        end
        OriginalTransparencies = {}
    end
end

local function setupClickTP(state)
    if Connections.ClickTP then Connections.ClickTP:Disconnect(); Connections.ClickTP = nil end
    if state then
        Connections.ClickTP = UserInputService.InputBegan:Connect(function(input, gpe)
            if gpe then return end 
            if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
                local hrp = getRoot(LocalPlayer.Character)
                if hrp and Mouse.Hit then 
                    hrp.CFrame = CFrame.new(Mouse.Hit.Position + Vector3.new(0, 3, 0)) 
                end
            end
        end)
    end
end

local function giveSpeedCoil()
    spawnItemSafe(99119158, "Speed Coil Added!", function(coil)
        coil.Equipped:Connect(function() 
            local c = LocalPlayer.Character
            if c and c:FindFirstChild("Humanoid") and not State.Speed then c.Humanoid.WalkSpeed = 90 end 
        end)
        coil.Unequipped:Connect(function() 
            local c = LocalPlayer.Character
            if c and c:FindFirstChild("Humanoid") and not State.Speed then c.Humanoid.WalkSpeed = 16 end 
        end)
    end)
end

local function giveGravityCoil()
    spawnItemSafe(16688968, "Gravity Coil Added!", function(coil)
        local floatForce = nil
        coil.Equipped:Connect(function()
            local c = LocalPlayer.Character
            if c and c:FindFirstChild("HumanoidRootPart") then
                local hum = c:FindFirstChild("Humanoid")
                if hum then hum.UseJumpPower = true; hum.JumpPower = 120 end
                local totalMass = 0
                for _, p in pairs(c:GetDescendants()) do 
                    if p:IsA("BasePart") then totalMass = totalMass + p.Mass end 
                end
                floatForce = Instance.new("BodyForce")
                floatForce.Name = "PrototypeGravCoil"
                floatForce.Force = Vector3.new(0, totalMass * Workspace.Gravity * 0.75, 0)
                floatForce.Parent = c.HumanoidRootPart
            end
        end)
        coil.Unequipped:Connect(function()
            local c = LocalPlayer.Character
            if c then 
                local hum = c:FindFirstChild("Humanoid")
                if hum then hum.JumpPower = 50 end
                if floatForce then floatForce:Destroy() end 
            end
        end)
    end)
end

local function giveSword()
    spawnItemSafe(10468915, "Sword Added!", function(sword)
        local anim = Instance.new("Animation")
        anim.AnimationId = "rbxassetid://218504594" 
        local track = nil
        sword.Equipped:Connect(function() 
            local c = LocalPlayer.Character
            local hum = c and c:FindFirstChild("Humanoid")
            if hum then track = hum:LoadAnimation(anim) end 
        end)
        sword.Activated:Connect(function() 
            if track then track:Play() end 
        end)
    end)
end

local function giveDeleteGun()
    local tool = Instance.new("Tool")
    tool.Name = "Delete Gun (Click)"
    tool.RequiresHandle = false
    tool.Parent = LocalPlayer.Backpack

    tool.Activated:Connect(function()
        local target = Mouse.Target
        if target and not target:IsDescendantOf(LocalPlayer.Character) then
            if not target.Parent:FindFirstChild("Humanoid") then
                Rayfield:Notify({Title = "Deleted", Content = "Removed: " .. target.Name, Duration = 2})
                target:Destroy()
            else 
                Rayfield:Notify({Title = "Blocked", Content = "You cannot delete other players.", Duration = 2}) 
            end
        end
    end)
    Rayfield:Notify({Title = "Success!", Content = "Delete Gun added to Backpack.", Duration = 3})
end

local function giveClickFling()
    local tool = Instance.new("Tool")
    tool.Name = "Click Fling (Props)"
    tool.RequiresHandle = false
    tool.Parent = LocalPlayer.Backpack

    tool.Activated:Connect(function()
        local target = Mouse.Target
        if target and not target:IsDescendantOf(LocalPlayer.Character) then
            if not target.Anchored then
                local bt = Instance.new("BodyThrust")
                bt.Force = Vector3.new(999999, 999999, 999999)
                bt.Location = target.Position + Vector3.new(0, 5, 0)
                bt.Parent = target
                task.delay(0.5, function() if bt then bt:Destroy() end end)
                Rayfield:Notify({Title = "Flinging!", Content = "Target launched.", Duration = 2})
            else 
                Rayfield:Notify({Title = "Blocked", Content = "Target is anchored.", Duration = 2}) 
            end
        end
    end)
    Rayfield:Notify({Title = "Success!", Content = "Click Fling Tool added to Backpack.", Duration = 3})
end

local function playTakeTheL()
    local char = LocalPlayer.Character
    local hum = char and char:FindFirstChildOfClass("Humanoid")
    local animator = hum and hum:FindFirstChildOfClass("Animator") or hum
    if not animator then return end
    
    if currentEmote then currentEmote:Stop(); currentEmote:Destroy() end
    
    local anim = Instance.new("Animation")
    anim.AnimationId = "rbxassetid://2442223104" 
    local success, _ = pcall(function() 
        currentEmote = animator:LoadAnimation(anim)
        currentEmote:Play() 
    end)
    if not success then 
        Rayfield:Notify({Title = "Emote Blocked", Content = "Roblox blocked this animation ID.", Duration = 4}) 
    end
end

local function updateSize()
    local char = LocalPlayer.Character
    local hum = char and char:FindFirstChildOfClass("Humanoid")
    if hum then
        pcall(function()
            local hd = hum:GetAppliedDescription()
            if hd then
                hd.HeadScale = State.HeadScale
                hd.WidthScale = State.BodyWidth
                hd.HeightScale = State.BodyHeight
                hum:ApplyDescription(hd)
            end
        end)
    end
end

-- ============================================================================
-- [12] UNLOADER MODULE
-- ============================================================================
local HubGui 
local Window 

local function UnloadScript()
    print("[Prototype] Unloading Script...")
    -- Disconnect everything
    for _, conn in pairs(Connections) do if conn then conn:Disconnect() end end
    Connections = {}
    
    -- Revert visuals
    clearESP()
    for _, line in pairs(TracerLines) do pcall(function() line:Remove() end) end
    for _, player in pairs(Players:GetPlayers()) do
        if player.Character and player.Character:FindFirstChild("PrototypeChams") then 
            player.Character.PrototypeChams:Destroy() 
        end
    end
    for prop, val in pairs(OriginalLighting) do pcall(function() Lighting[prop] = val end) end
    Camera.FieldOfView = 70
    setupXRay(false)

    -- Revert Character
    if FreecamPart then FreecamPart:Destroy() end
    if FlyInstances.NormalFly then for _, i in pairs(FlyInstances.NormalFly) do i:Destroy() end end
    if FlyInstances.Heli then for _, i in pairs(FlyInstances.Heli) do i:Destroy() end end
    if SpiderInstances then for _, i in pairs(SpiderInstances) do i:Destroy() end end
    if CarFlyInstances then for _, i in pairs(CarFlyInstances) do i:Destroy() end end
    for _, p in pairs(CarpetParts) do if p then p:Destroy() end end

    local char = LocalPlayer.Character
    if char then
        local hum = char:FindFirstChild("Humanoid")
        if hum then 
            hum.WalkSpeed = 16
            hum.PlatformStand = false
            hum.Sit = false 
        end
        local hrp = char:FindFirstChild("HumanoidRootPart")
        if hrp then
            if hrp:FindFirstChild("PrototypeHoverVel") then hrp.PrototypeHoverVel:Destroy() end
            if hrp:FindFirstChild("PrototypeInvGravBF") then hrp.PrototypeInvGravBF:Destroy() end
            if hrp:FindFirstChild("PrototypeInvGravBG") then hrp.PrototypeInvGravBG:Destroy() end
            if hrp:FindFirstChild("PrototypeMoonGrav") then hrp.PrototypeMoonGrav:Destroy() end
        end
        Camera.CameraSubject = hum
        State.HeadScale = 1; State.BodyWidth = 1; State.BodyHeight = 1; updateSize()
    end

    if HubGui then HubGui:Destroy() end
    if FOVCircle then pcall(function() FOVCircle:Remove() end) end
    if Rayfield then Rayfield:Destroy() end
    print("[Prototype] Unload Complete.")
end

-- ============================================================================
-- [13] CUSTOM PREMIUM VISUAL PLAYER HUB
-- ============================================================================
HubGui = Instance.new("ScreenGui")
HubGui.Name = "PrototypeVisualHub"
HubGui.ResetOnSpawn = false
local successHub = pcall(function() HubGui.Parent = CoreGui end)
if not successHub then HubGui.Parent = LocalPlayer:WaitForChild("PlayerGui") end

local HubFrame = Instance.new("Frame", HubGui)
HubFrame.Size = UDim2.new(0, 400, 0, 350)
HubFrame.Position = UDim2.new(0.5, -200, 0.5, -175)
HubFrame.BackgroundColor3 = Color3.fromRGB(11, 11, 18)
HubFrame.Visible = false
HubFrame.Active = true
HubFrame.Draggable = true

local HubCorner = Instance.new("UICorner", HubFrame)
HubCorner.CornerRadius = UDim.new(0, 12)

local HubStroke = Instance.new("UIStroke", HubFrame)
HubStroke.Color = Color3.new(1,1,1)
HubStroke.Thickness = 2

local HubGrad = Instance.new("UIGradient", HubStroke)
HubGrad.Color = ColorSequence.new{ColorSequenceKeypoint.new(0, Color3.fromRGB(255,0,127)), ColorSequenceKeypoint.new(1, Color3.fromRGB(0,225,255))}
HubGrad.Rotation = 45

local HubTitle = Instance.new("TextLabel", HubFrame)
HubTitle.Size = UDim2.new(1, 0, 0, 45)
HubTitle.BackgroundTransparency = 1
HubTitle.Text = "  LIVE PLAYER HUB"
HubTitle.TextColor3 = Color3.new(1,1,1)
HubTitle.Font = Enum.Font.GothamBlack
HubTitle.TextSize = 18
HubTitle.TextXAlignment = Enum.TextXAlignment.Left

local TitleGrad = Instance.new("UIGradient", HubTitle)
TitleGrad.Color = HubGrad.Color
TitleGrad.Rotation = 45

local CloseBtn = Instance.new("TextButton", HubFrame)
CloseBtn.Size = UDim2.new(0, 30, 0, 30)
CloseBtn.Position = UDim2.new(1, -40, 0, 7)
CloseBtn.BackgroundColor3 = Color3.fromRGB(255, 50, 50)
CloseBtn.Text = "X"
CloseBtn.TextColor3 = Color3.new(1,1,1)
CloseBtn.Font = Enum.Font.GothamBold
CloseBtn.TextSize = 14

local CloseCorner = Instance.new("UICorner", CloseBtn)
CloseCorner.CornerRadius = UDim.new(0, 6)
CloseBtn.MouseButton1Click:Connect(function() HubFrame.Visible = false end)

local HubScroll = Instance.new("ScrollingFrame", HubFrame)
HubScroll.Size = UDim2.new(1, -20, 1, -60)
HubScroll.Position = UDim2.new(0, 10, 0, 50)
HubScroll.BackgroundTransparency = 1
HubScroll.ScrollBarThickness = 2
HubScroll.CanvasSize = UDim2.new(0, 0, 0, 0)
HubScroll.AutomaticCanvasSize = Enum.AutomaticSize.Y
HubScroll.ScrollBarImageColor3 = Color3.fromRGB(0,225,255)

local HubListLayout = Instance.new("UIListLayout", HubScroll)
HubListLayout.SortOrder = Enum.SortOrder.LayoutOrder
HubListLayout.Padding = UDim.new(0, 8)

local function applyHubTheme(color1, color2, scrollColor)
    HubGrad.Color = ColorSequence.new{ColorSequenceKeypoint.new(0, color1), ColorSequenceKeypoint.new(1, color2)}
    TitleGrad.Color = HubGrad.Color
    HubScroll.ScrollBarImageColor3 = scrollColor
end

local function refreshVisualHub()
    for _, child in pairs(HubScroll:GetChildren()) do 
        if child:IsA("Frame") then child:Destroy() end 
    end
    for _, player in pairs(Players:GetPlayers()) do
        if player ~= LocalPlayer then
            local pFrame = Instance.new("Frame", HubScroll)
            pFrame.Size = UDim2.new(1, 0, 0, 50)
            pFrame.BackgroundColor3 = Color3.fromRGB(20, 20, 30)
            
            local pCorner = Instance.new("UICorner", pFrame)
            pCorner.CornerRadius = UDim.new(0, 8)
            
            local img = Instance.new("ImageLabel", pFrame)
            img.Size = UDim2.new(0, 36, 0, 36)
            img.Position = UDim2.new(0, 7, 0.5, -18)
            img.BackgroundTransparency = 1
            pcall(function() img.Image = Players:GetUserThumbnailAsync(player.UserId, Enum.ThumbnailType.HeadShot, Enum.ThumbnailSize.Size420x420) end)
            
            local name = Instance.new("TextLabel", pFrame)
            name.Size = UDim2.new(0, 150, 1, 0)
            name.Position = UDim2.new(0, 55, 0, 0)
            name.BackgroundTransparency = 1
            name.Text = player.Name
            name.TextColor3 = Color3.new(1,1,1)
            name.Font = Enum.Font.GothamSemibold
            name.TextSize = 14
            name.TextXAlignment = Enum.TextXAlignment.Left

            local tpBtn = Instance.new("TextButton", pFrame)
            tpBtn.Size = UDim2.new(0, 50, 0, 26)
            tpBtn.Position = UDim2.new(1, -120, 0.5, -13)
            tpBtn.BackgroundColor3 = Color3.fromRGB(40,40,50)
            tpBtn.Text = "TP"
            tpBtn.TextColor3 = Color3.new(1,1,1)
            tpBtn.Font = Enum.Font.GothamBold
            tpBtn.TextSize = 12
            Instance.new("UICorner", tpBtn).CornerRadius = UDim.new(0, 6)

            local bringBtn = Instance.new("TextButton", pFrame)
            bringBtn.Size = UDim2.new(0, 50, 0, 26)
            bringBtn.Position = UDim2.new(1, -60, 0.5, -13)
            bringBtn.BackgroundColor3 = Color3.fromRGB(40,40,50)
            bringBtn.Text = "BRING"
            bringBtn.TextColor3 = Color3.new(1,1,1)
            bringBtn.Font = Enum.Font.GothamBold
            bringBtn.TextSize = 12
            Instance.new("UICorner", bringBtn).CornerRadius = UDim.new(0, 6)

            tpBtn.MouseButton1Click:Connect(function() 
                local t = getRoot(player.Character)
                local l = getRoot(LocalPlayer.Character)
                if t and l then l.CFrame = t.CFrame * CFrame.new(0, 0, 3) end 
            end)
            bringBtn.MouseButton1Click:Connect(function() 
                local t = getRoot(player.Character)
                local l = getRoot(LocalPlayer.Character)
                if t and l then t.CFrame = l.CFrame * CFrame.new(0, 0, -3) end 
            end)
        end
    end
end
Players.PlayerAdded:Connect(function() task.spawn(refreshVisualHub) end)
Players.PlayerRemoving:Connect(function() task.spawn(refreshVisualHub) end)
task.spawn(refreshVisualHub)


-- ============================================================================
-- [14] BUILD EXPLICIT RAYFIELD UI & KEYBINDS (ZERO MACROS)
-- ============================================================================
print("[Prototype] Building Menu Interface...")

Window = Rayfield:CreateWindow({
    Name = "Prototype Menu",
    LoadingTitle = "Prototype Menu",
    LoadingSubtitle = "The Behemoth Edition",
    Theme = SavedTheme, 
    ConfigurationSaving = { Enabled = false },
    Discord = { Enabled = false },
    KeySystem = false,
})

local TabMove = Window:CreateTab("Movement", 4483362458)
local TabCombat = Window:CreateTab("Combat", 4483362458)
local TabVisual = Window:CreateTab("Visuals", 4483362458)
local TabUtility = Window:CreateTab("Utility", 4483362458)
local TabSettings = Window:CreateTab("Settings", 4483362458)
local TabPlayers = Window:CreateTab("Player Hub", 4483362458)

-- Movement Elements
Toggles.Fly = TabMove:CreateToggle({ Name = "Fly", CurrentValue = false, Callback = function(v) State.Fly = v; setupFly(v) end })
Toggles.CarFly = TabMove:CreateToggle({ Name = "Car Fly (Must be in Driver Seat)", CurrentValue = false, Callback = function(v) State.CarFly = v; setupCarFly(v) end })
Toggles.FEHeli = TabMove:CreateToggle({ Name = "FE Helicopter (Server Visible)", CurrentValue = false, Callback = function(v) State.FEHelicopter = v; setupFEHelicopter(v) end })
TabMove:CreateButton({ Name = "Dash Forward (3.5s CD)", Callback = function() executeDash() end })
Toggles.MagicCarpet = TabMove:CreateToggle({ Name = "Magic Carpet (Air Walk)", CurrentValue = false, Callback = function(v) State.MagicCarpet = v; setupMagicCarpet(v) end })
Toggles.SpiderClimb = TabMove:CreateToggle({ Name = "Spider Climb (Hold W on Walls)", CurrentValue = false, Callback = function(v) State.SpiderClimb = v; setupSpiderClimb(v) end })
Toggles.Freecam = TabMove:CreateToggle({ Name = "Freecam (Drone Mode)", CurrentValue = false, Callback = function(v) State.Freecam = v; setupFreecam(v) end })
TabMove:CreateButton({ Name = "Freecam Teleport", Callback = function() executeFreecamTP() end })
Toggles.Hover = TabMove:CreateToggle({ Name = "Hover", CurrentValue = false, Callback = function(v) State.Hover = v; setupHover(v) end })
Toggles.MoonGravity = TabMove:CreateToggle({ Name = "Moon Gravity (Low Gravity)", CurrentValue = false, Callback = function(v) State.MoonGravity = v; setupMoonGravity(v) end })
Toggles.InvGravity = TabMove:CreateToggle({ Name = "Inverted Gravity", CurrentValue = false, Callback = function(v) State.InvGravity = v; setupInvGravity(v) end })
Toggles.Speed = TabMove:CreateToggle({ Name = "Speed Boost", CurrentValue = false, Callback = function(v) State.Speed = v; setupSpeed(v) end })
Toggles.Noclip = TabMove:CreateToggle({ Name = "Noclip", CurrentValue = false, Callback = function(v) State.Noclip = v; setupNoclip(v) end })
Toggles.InfJump = TabMove:CreateToggle({ Name = "Infinite Jump", CurrentValue = false, Callback = function(v) State.InfJump = v end })

-- Combat Elements
TabCombat:CreateLabel("--- DEFENSE & RECON ---")
Toggles.AntiRagdoll = TabCombat:CreateToggle({ Name = "Anti-Ragdoll (Immune to Tripping)", CurrentValue = false, Callback = function(v) State.AntiRagdoll = v; setupAntiRagdoll(v) end })
Toggles.AntiCheatBypass = TabCombat:CreateToggle({ Name = "Anti-Cheat Bypass (Velocity Spoof)", CurrentValue = false, Callback = function(v) State.AntiCheatBypass = v; setupAntiCheatBypass(v) end })
TabCombat:CreateButton({ Name = "Heal Player (Local Only)", Callback = function() local char = LocalPlayer.Character; if char and char:FindFirstChild("Humanoid") then char.Humanoid.Health = char.Humanoid.MaxHealth; Rayfield:Notify({Title = "Healed", Content = "Health restored locally.", Duration = 4}) end end })
TabCombat:CreateButton({ Name = "Enable Local God Mode", Callback = function() local char = LocalPlayer.Character; if char and char:FindFirstChild("Humanoid") then char.Humanoid.MaxHealth = math.huge; char.Humanoid.Health = math.huge; Rayfield:Notify({Title = "God Mode", Content = "Local God Mode active.", Duration = 4}) end end })
Toggles.Hitbox = TabCombat:CreateToggle({ Name = "Hitbox Expander", CurrentValue = false, Callback = function(v) State.Hitbox = v; setupHitbox(v) end })
Toggles.RandomTP = TabCombat:CreateToggle({ Name = "Auto-Teleport Behind Random Players", CurrentValue = false, Callback = function(v) State.RandomTP = v; setupRandomTP(v) end })
TabCombat:CreateSlider({ Name = "Random TP Interval", Range = {5, 200}, Increment = 5, Suffix = "sec", CurrentValue = 20, Callback = function(v) State.RandomTPInterval = v / 10 end })

TabCombat:CreateLabel("--- WEAPON MODS ---")
Toggles.Triggerbot = TabCombat:CreateToggle({ Name = "Universal Triggerbot (Auto-Shoot)", CurrentValue = false, Callback = function(v) State.Triggerbot = v; setupTriggerbot(v) end })
TabCombat:CreateSlider({ Name = "Triggerbot Delay", Range = {0, 10}, Increment = 1, Suffix = "sec", CurrentValue = 0, Callback = function(v) State.TriggerDelay = v / 10 end })

TabCombat:CreateLabel("--- AIMBOT SYSTEM ---")
Toggles.CamLock = TabCombat:CreateToggle({ Name = "Player Aimbot (FOV)", CurrentValue = false, Callback = function(v) State.CamLock = v; setupMasterAimbot() end })
Toggles.LockBot = TabCombat:CreateToggle({ Name = "Player LockBot (360° Physical)", CurrentValue = false, Callback = function(v) State.LockBot = v; if v and not State.CamLock and Toggles.CamLock then Toggles.CamLock:Set(true) end; setupMasterAimbot() end })
Toggles.NPCCamLock = TabCombat:CreateToggle({ Name = "NPC Aimbot (FOV)", CurrentValue = false, Callback = function(v) State.NPCCamLock = v; setupMasterAimbot() end })
Toggles.NPCLockBot = TabCombat:CreateToggle({ Name = "NPC LockBot (360° Physical)", CurrentValue = false, Callback = function(v) State.NPCLockBot = v; if v and not State.NPCCamLock and Toggles.NPCCamLock then Toggles.NPCCamLock:Set(true) end; setupMasterAimbot() end })

TabCombat:CreateSlider({ Name = "Prediction Power (Lead Target)", Range = {0, 20}, Increment = 1, Suffix = "Power", CurrentValue = 0, Callback = function(v) State.AimPrediction = v end })
TabCombat:CreateSlider({ Name = "Aimbot Smoothness", Range = {1, 10}, Increment = 1, Suffix = "L", CurrentValue = 5, Callback = function(v) State.CamLockSmoothness = v / 10 end })
TabCombat:CreateSlider({ Name = "Aimbot FOV Size", Range = {50, 400}, Increment = 10, Suffix = "px", CurrentValue = 150, Callback = function(v) State.CamLockFOV = v end })
Toggles.ShowFOV = TabCombat:CreateToggle({ Name = "Show Aimbot FOV Circle", CurrentValue = false, Callback = function(v) State.ShowFOV = v end })

-- Visual Elements
Toggles.XRay = TabVisual:CreateToggle({ Name = "X-Ray Vision (See Through Map)", CurrentValue = false, Callback = function(v) State.XRay = v; setupXRay(v) end })
TabVisual:CreateSlider({ Name = "X-Ray Opacity", Range = {1, 9}, Increment = 1, Suffix = " (x0.1)", CurrentValue = 5, Callback = function(v) State.XRayOpacity = v / 10; if State.XRay then setupXRay(true) end end })
Toggles.ESP = TabVisual:CreateToggle({ Name = "Distance ESP", CurrentValue = false, Callback = function(v) State.ESP = v; setupESP(v) end })
Toggles.Chams = TabVisual:CreateToggle({ Name = "Chams (Red Wallhack)", CurrentValue = false, Callback = function(v) State.Chams = v; setupChams(v) end })
Toggles.Tracers = TabVisual:CreateToggle({ Name = "Foot Tracers (Drawing API)", CurrentValue = false, Callback = function(v) State.Tracers = v; setupTracers(v) end })
Toggles.TeamCheck = TabVisual:CreateToggle({ Name = "Team Check (ESP / Tracers / Aimbot)", CurrentValue = false, Callback = function(v) State.TeamCheck = v end })
Toggles.Fullbright = TabVisual:CreateToggle({ Name = "Fullbright", CurrentValue = false, Callback = function(v) State.Fullbright = v; setupFullbright(v) end })

-- Utility Elements
Toggles.VoidSaver = TabUtility:CreateToggle({ Name = "Anti-Void (Void Saver)", CurrentValue = false, Callback = function(v) State.VoidSaver = v; setupVoidSaver(v) end })

TabUtility:CreateLabel("--- TOOLS & SPAWNERS ---")
TabUtility:CreateButton({ Name = "Get Click-Fling Tool (Props)", Callback = function() giveClickFling() end })
TabUtility:CreateButton({ Name = "Get Delete Gun", Callback = function() giveDeleteGun() end })
TabUtility:CreateButton({ Name = "Get Speed Coil", Callback = function() giveSpeedCoil() end })
TabUtility:CreateButton({ Name = "Get Gravity Coil", Callback = function() giveGravityCoil() end })
TabUtility:CreateButton({ Name = "Get Classic Sword", Callback = function() giveSword() end })
TabUtility:CreateButton({ Name = "Spawn Custom Item (225921000)", Callback = function() spawnItemSafe(225921000, "Spawned Custom Item!") end })
TabUtility:CreateButton({ Name = "Spawn HD Admin (Local/Visual Only)", Callback = function() spawnItemSafe(146910609, "HD Admin spawned locally.") end })

TabUtility:CreateLabel("--- WORLD MODS ---")
TabUtility:CreateButton({ Name = "Play 'Take The L' Emote", Callback = function() playTakeTheL() end })
Toggles.BuildMode = TabUtility:CreateToggle({ Name = "Build Mode", CurrentValue = false, Callback = function(v) State.BuildMode = v; setupBuildMode(v) end })
TabUtility:CreateButton({ Name = "Undo Last Slab", Callback = function() undoSlab() end })
Toggles.Invisibility = TabUtility:CreateToggle({ Name = "Local Invisibility", CurrentValue = false, Callback = function(v) State.Invisibility = v; setupInvis(v) end })
Toggles.ClickTP = TabUtility:CreateToggle({ Name = "Click TP", CurrentValue = false, Callback = function(v) State.ClickTP = v; setupClickTP(v) end })

-- Settings Elements
TabSettings:CreateLabel("--- SERVER-SIDED SIZE MODIFIERS ---")
TabSettings:CreateSlider({ Name = "Head Scale", Range = {1, 50}, Increment = 1, Suffix = "x", CurrentValue = 10, Callback = function(v) State.HeadScale = v / 10; updateSize() end })
TabSettings:CreateSlider({ Name = "Body Width", Range = {1, 50}, Increment = 1, Suffix = "x", CurrentValue = 10, Callback = function(v) State.BodyWidth = v / 10; updateSize() end })
TabSettings:CreateSlider({ Name = "Body Height", Range = {1, 50}, Increment = 1, Suffix = "x", CurrentValue = 10, Callback = function(v) State.BodyHeight = v / 10; updateSize() end })

TabSettings:CreateLabel("--- THEMES & CONFIG ---")
TabSettings:CreateDropdown({
    Name = "Main Menu Theme (Requires Re-execute)",
    Options = {"Amethyst", "Ocean", "Light", "Serenity", "DarkBlue", "Green"},
    CurrentOption = {SavedTheme},
    MultipleOptions = false,
    Callback = function(Option)
        pcall(function()
            if writefile then writefile("PrototypeMenuTheme.txt", Option[1]) end
            Rayfield:Notify({Title = "Theme Saved", Content = "Re-execute script to see changes.", Duration = 4})
        end)
    end,
})
TabSettings:CreateDropdown({
    Name = "Visual Player Hub Theme",
    Options = {"Amethyst (Default)", "Ocean", "Ruby", "Emerald", "Gold"},
    CurrentOption = {"Amethyst (Default)"},
    MultipleOptions = false,
    Callback = function(Option)
        local choice = Option[1]
        if choice == "Amethyst (Default)" then applyHubTheme(Color3.fromRGB(255,0,127), Color3.fromRGB(0,225,255), Color3.fromRGB(0,225,255))
        elseif choice == "Ocean" then applyHubTheme(Color3.fromRGB(0,150,255), Color3.fromRGB(0,255,150), Color3.fromRGB(0,255,150))
        elseif choice == "Ruby" then applyHubTheme(Color3.fromRGB(255,0,50), Color3.fromRGB(255,100,0), Color3.fromRGB(255,50,50))
        elseif choice == "Emerald" then applyHubTheme(Color3.fromRGB(0,255,100), Color3.fromRGB(50,200,50), Color3.fromRGB(0,255,100))
        elseif choice == "Gold" then applyHubTheme(Color3.fromRGB(255,200,0), Color3.fromRGB(255,255,0), Color3.fromRGB(255,200,0))
        end
    end,
})

TabSettings:CreateLabel("--- EXPLICIT KEYBINDS ---")
TabSettings:CreateKeybind({ Name = "Fly Keybind", CurrentKeybind = "E", HoldToInteract = false, Callback = function() if Toggles.Fly then Toggles.Fly:Set(not State.Fly) end end })
TabSettings:CreateKeybind({ Name = "Dash Keybind", CurrentKeybind = "Q", HoldToInteract = false, Callback = function() executeDash() end })
TabSettings:CreateKeybind({ Name = "Freecam Keybind", CurrentKeybind = "Minus", HoldToInteract = false, Callback = function() if Toggles.Freecam then Toggles.Freecam:Set(not State.Freecam) end end })
TabSettings:CreateKeybind({ Name = "Freecam TP Keybind", CurrentKeybind = "F7", HoldToInteract = false, Callback = function() executeFreecamTP() end })
TabSettings:CreateKeybind({ Name = "Hover Keybind", CurrentKeybind = "K", HoldToInteract = false, Callback = function() if Toggles.Hover then Toggles.Hover:Set(not State.Hover) end end })
TabSettings:CreateKeybind({ Name = "Inv Gravity Keybind", CurrentKeybind = "RightBracket", HoldToInteract = false, Callback = function() if Toggles.InvGravity then Toggles.InvGravity:Set(not State.InvGravity) end end })
TabSettings:CreateKeybind({ Name = "Speed Keybind", CurrentKeybind = "X", HoldToInteract = false, Callback = function() if Toggles.Speed then Toggles.Speed:Set(not State.Speed) end end })
TabSettings:CreateKeybind({ Name = "Noclip Keybind", CurrentKeybind = "M", HoldToInteract = false, Callback = function() if Toggles.Noclip then Toggles.Noclip:Set(not State.Noclip) end end })
TabSettings:CreateKeybind({ Name = "Player Aimbot Keybind", CurrentKeybind = "C", HoldToInteract = false, Callback = function() if Toggles.CamLock then Toggles.CamLock:Set(not State.CamLock) end end })
TabSettings:CreateKeybind({ Name = "NPC Aimbot Keybind", CurrentKeybind = "Y", HoldToInteract = false, Callback = function() if Toggles.NPCCamLock then Toggles.NPCCamLock:Set(not State.NPCCamLock) end end })
TabSettings:CreateKeybind({ Name = "Triggerbot Keybind", CurrentKeybind = "T", HoldToInteract = false, Callback = function() if Toggles.Triggerbot then Toggles.Triggerbot:Set(not State.Triggerbot) end end })
TabSettings:CreateKeybind({ Name = "ESP Keybind", CurrentKeybind = "Equals", HoldToInteract = false, Callback = function() if Toggles.ESP then Toggles.ESP:Set(not State.ESP) end end })
TabSettings:CreateKeybind({ Name = "X-Ray Keybind", CurrentKeybind = "B", HoldToInteract = false, Callback = function() if Toggles.XRay then Toggles.XRay:Set(not State.XRay) end end })
TabSettings:CreateKeybind({ Name = "Fullbright Keybind", CurrentKeybind = "N", HoldToInteract = false, Callback = function() if Toggles.Fullbright then Toggles.Fullbright:Set(not State.Fullbright) end end })
TabSettings:CreateKeybind({ Name = "Build Mode Keybind", CurrentKeybind = "Insert", HoldToInteract = false, Callback = function() if Toggles.BuildMode then Toggles.BuildMode:Set(not State.BuildMode) end end })
TabSettings:CreateKeybind({ Name = "Undo Slab Keybind", CurrentKeybind = "Delete", HoldToInteract = false, Callback = function() undoSlab() end })

TabSettings:CreateLabel("--- TWEAKS ---")
TabSettings:CreateToggle({ Name = "Enable Keybinds (Master Switch)", CurrentValue = true, Callback = function(v) State.KeybindsEnabled = v end })
Toggles.CarSpeedToggle = TabSettings:CreateToggle({ Name = "Enable Car Speed Boost", CurrentValue = false, Callback = function(v) State.CarSpeedEnabled = v; setupCarSpeed(v) end })
TabSettings:CreateSlider({ Name = "Car Speed Multiplier", Range = {10, 500}, Increment = 10, Suffix = "Power", CurrentValue = 100, Callback = function(v) State.CarSpeed = v end })
TabSettings:CreateSlider({ Name = "Camera FOV", Range = {70, 120}, Increment = 5, Suffix = "FOV", CurrentValue = 70, Callback = function(v) State.FOV = v end })
TabSettings:CreateSlider({ Name = "Fly/Freecam Speed", Range = {10, 500}, Increment = 10, Suffix = "Speed", CurrentValue = 100, Callback = function(v) State.FlySpeed = v end })
TabSettings:CreateSlider({ Name = "Walk Speed", Range = {16, 500}, Increment = 5, Suffix = "Speed", CurrentValue = 175, Callback = function(v) State.WalkSpeed = v end })
TabSettings:CreateButton({ Name = "🚨 DESTROY MENU (UNLOAD SCRIPT)", Callback = function() UnloadScript() end })

-- Player Hub Elements
local TargetPlayer = nil
local PlayerDropdown = TabPlayers:CreateDropdown({
    Name = "Select a Player",
    Options = {"Waiting for players..."},
    CurrentOption = {""},
    MultipleOptions = false,
    Callback = function(Option) TargetPlayer = Option[1] end,
})

TabPlayers:CreateButton({
    Name = "Spectate Player",
    Callback = function()
        if TargetPlayer and Players:FindFirstChild(TargetPlayer) then
            local targetChar = Players[TargetPlayer].Character
            local targetHum = targetChar and targetChar:FindFirstChild("Humanoid")
            if targetHum then Camera.CameraSubject = targetHum end
        end
    end
})

TabPlayers:CreateButton({
    Name = "Stop Spectating",
    Callback = function()
        local myHum = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("Humanoid")
        if myHum then Camera.CameraSubject = myHum end
    end
})

TabPlayers:CreateButton({
    Name = "Open Premium Visual Player Hub",
    Callback = function() HubFrame.Visible = not HubFrame.Visible end
})

local function initDropdown()
    local list = {}
    for _, p in pairs(Players:GetPlayers()) do
        if p ~= LocalPlayer then table.insert(list, p.Name) end
    end
    if #list == 0 then table.insert(list, "No other players") end
    pcall(function() PlayerDropdown:Refresh(list) end)
end
Players.PlayerAdded:Connect(function() task.spawn(initDropdown) end)
Players.PlayerRemoving:Connect(function() task.spawn(initDropdown) end)

-- ============================================================================
-- [15] GLOBAL INPUT FALLBACK & RESPAWN HANDLER
-- ============================================================================
UserInputService.InputBegan:Connect(function(input, gpe)
    if not State.KeybindsEnabled then return end 
    if UserInputService:GetFocusedTextBox() then return end 
    
    -- Fallback execution for abilities that don't need Toggles
    if input.KeyCode == Enum.KeyCode.Q and not gpe then executeDash() end
    if input.KeyCode == Enum.KeyCode.F7 and not gpe then executeFreecamTP() end
    if input.KeyCode == Enum.KeyCode.Delete and not gpe then undoSlab() end
end)

LocalPlayer.CharacterAdded:Connect(function()
    task.wait(0.5)
    -- Restore Physics and Visuals
    if State.Fly then setupFly(true) end
    if State.FEHelicopter then setupFEHelicopter(true) end
    if State.Freecam then setupFreecam(true) end
    if State.Hover then setupHover(true) end
    if State.MoonGravity then setupMoonGravity(true) end
    if State.InvGravity then setupInvGravity(true) end
    if State.Invisibility then setupInvis(true) end
    if State.SpiderClimb then setupSpiderClimb(true) end
    if State.AntiRagdoll then setupAntiRagdoll(true) end
    if State.VoidSaver then setupVoidSaver(true) end
    if State.AntiCheatBypass then setupAntiCheatBypass(true) end
    if State.XRay then setupXRay(true) end
    if State.MagicCarpet then setupMagicCarpet(true) end
    if State.CarFly then setupCarFly(true) end
    if State.CarSpeedEnabled then setupCarSpeed(true) end
    
    -- Restore Combat Systems
    if State.CamLock or State.LockBot or State.NPCCamLock or State.NPCLockBot then setupMasterAimbot() end
    if State.Triggerbot then setupTriggerbot(true) end
    if State.RandomTP then setupRandomTP(true) end
    
    -- Restore Modifiers
    updateSize()
end)

print("[Prototype] Loading Complete.")
Rayfield:Notify({
    Title = "Prototype Menu Loaded",
    Content = "V62 Behemoth Edition successfully executed.",
    Duration = 5,
    Image = 4483362458,
})