Auto Farm Sharks (Instant TP) Keyless

local WindUI = loadstring(game:HttpGet("https://github.com/Footagesus/WindUI/releases/latest/download/main.lua"))()

local Window = WindUI:CreateWindow({
    Title = "Sharkbite Classic",
    Icon = "fish", -- lucide icon
    Author = "by scriptings hub",
    Folder = "Sharkbite Classic",
    
    -- ↓ This all is Optional. You can remove it.
    Size = UDim2.fromOffset(580, 460),
    MinSize = Vector2.new(560, 350),
    MaxSize = Vector2.new(850, 560),
    ToggleKey = Enum.KeyCode.LeftShift,
    Transparent = true,
    Theme = "Dark",
    Resizable = true,
    SideBarWidth = 200,
    BackgroundImageTransparency = 0.42,
    HideSearchBar = true,
    ScrollBarEnabled = false,


    
    -- ↓ Optional. You can remove it.
    --[[ You can set 'rbxassetid://' or video to Background.
        'rbxassetid://':
            Background = "rbxassetid://", -- rbxassetid
        Video:
            Background = "video:YOUR-RAW-LINK-TO-VIDEO.webm", -- video 
    --]]
    
    -- ↓ Optional. You can remove it.
    User = {
        Enabled = true,
        Anonymous = false,
        Callback = function()
            print("clicked")
        end,
    },


})

Window:EditOpenButton({
    Title = "Sharkbite Classic",
    Icon = "fish",
    CornerRadius = UDim.new(0,16),
    StrokeThickness = 2,
    Color = ColorSequence.new( -- gradient
        Color3.fromHex("FF0F7B"), 
        Color3.fromHex("F89B29")
    ),
    OnlyMobile = false,
    Enabled = true,
    Draggable = true,
})

local Tab = Window:Tab({
    Title = "Local Player",
    Locked = false,
})

WindUI:Notify({
    Title = "Script Loading",
    Content = "Thanks for using the best keyless script for sharkbite classic!",
    Duration = 3, -- 3 seconds
    Icon = "monitor",
})

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

local Slider = Tab:Slider({
    Title = "Set Walkspeed",
    Desc = "Changes your movement speed",
    Step = 1,
    Value = {
        Min = 16,
        Max = 500,
        Default = 16,
    },
    Callback = function(value)
        local character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
        local humanoid = character:FindFirstChildOfClass("Humanoid")
        
        if humanoid then
            humanoid.WalkSpeed = value
        end
    end
})

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

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local LocalPlayer = Players.LocalPlayer

local currentJumpValue = 50

-- Keeps jump power active constantly so the game can't reset it on jump
RunService.RenderStepped:Connect(function()
    local character = LocalPlayer.Character
    if character then
        local humanoid = character:FindFirstChildOfClass("Humanoid")
        if humanoid then
            humanoid.UseJumpPower = true
            humanoid.JumpPower = currentJumpValue
            humanoid.JumpHeight = currentJumpValue / 7 -- Converts power to equivalent height if game uses JumpHeight
        end
    end
end)

local Slider = Tab:Slider({
    Title = "Set Jump Power",
    Desc = "Changes how high you jump",
    Step = 1,
    Value = {
        Min = 50,
        Max = 500,
        Default = 50,
    },
    Callback = function(value)
        currentJumpValue = value
    end
})

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local LocalPlayer = Players.LocalPlayer

local currentSwimSpeed = 16

RunService.RenderStepped:Connect(function(dt)
    local character = LocalPlayer.Character
    if not character then return end
    
    local humanoid = character:FindFirstChildOfClass("Humanoid")
    local rootPart = character:FindFirstChild("HumanoidRootPart")
    
    if humanoid and rootPart then
        -- Check if player is in swimming state
        if humanoid:GetState() == Enum.HumanoidStateType.Swimming then
            local moveDir = humanoid.MoveDirection
            
            -- Only move when pressing movement keys
            if moveDir.Magnitude > 0 then
                -- Standard Roblox swim speed is ~16, calculate multiplier boost
                local speedMultiplier = (currentSwimSpeed - 16)
                
                if speedMultiplier > 0 then
                    -- Shift CFrame directly forward frame-by-frame
                    rootPart.CFrame = rootPart.CFrame + (moveDir * (speedMultiplier * dt))
                end
            end
        end
    end
end)

local Slider = Tab:Slider({
    Title = "Set Swim Speed",
    Desc = "Changes how fast you swim in water",
    Step = 1,
    Value = {
        Min = 16,
        Max = 500,
        Default = 16,
    },
    Callback = function(value)
        currentSwimSpeed = value
    end
})

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local LocalPlayer = Players.LocalPlayer

local noclipEnabled = false
local noclipConnection = nil

local Toggle = Tab:Toggle({
    Title = "Noclip",
    Desc = "Allows you to pass through walls",
    Default = false,
    Callback = function(state)
        noclipEnabled = state
        
        -- Clean up existing connection if toggled off
        if noclipConnection then
            noclipConnection:Disconnect()
            noclipConnection = nil
        end
        
        -- Enable loop when toggle is active
        if noclipEnabled then
            noclipConnection = RunService.Stepped:Connect(function()
                local character = LocalPlayer.Character
                if character then
                    for _, part in ipairs(character:GetDescendants()) do
                        if part:IsA("BasePart") then
                            part.CanCollide = false
                        end
                    end
                end
            end)
        end
    end
})

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

local LocalPlayer = Players.LocalPlayer
local Camera = workspace.CurrentCamera

local freecamEnabled = false
local cameraConnection = nil
local speed = 1 -- Adjust camera speed here

local Toggle = Tab:Toggle({
    Title = "Noclip Camera (Freecam)",
    Desc = "Fly camera freely through walls",
    Default = false,
    Callback = function(state)
        freecamEnabled = state
        
        if noclipConnection then
            noclipConnection:Disconnect()
            noclipConnection = nil
        end

        if freecamEnabled then
            -- Switch camera to Scriptable mode
            Camera.CameraType = Enum.CameraType.Scriptable
            
            noclipConnection = RunService.RenderStepped:Connect(function(dt)
                if not freecamEnabled then return end
                
                local moveVector = Vector3.new(0, 0, 0)
                
                -- Standard WASD + E/Q movement
                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.D) then moveVector = moveVector + Camera.CFrame.RightVector end
                if UserInputService:IsKeyDown(Enum.KeyCode.A) then moveVector = moveVector - Camera.CFrame.RightVector end
                if UserInputService:IsKeyDown(Enum.KeyCode.E) then moveVector = moveVector + Vector3.new(0, 1, 0) end
                if UserInputService:IsKeyDown(Enum.KeyCode.Q) then moveVector = moveVector - Vector3.new(0, 1, 0) end
                
                -- Move camera position
                Camera.CFrame = Camera.CFrame + (moveVector * (speed * 50 * dt))
            end)
        else
            -- Reset camera back to normal character view
            Camera.CameraType = Enum.CameraType.Custom
            if LocalPlayer.Character and LocalPlayer.Character:FindFirstChildOfClass("Humanoid") then
                Camera.CameraSubject = LocalPlayer.Character:FindFirstChildOfClass("Humanoid")
            end
        end
    end
})

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local LocalPlayer = Players.LocalPlayer

local currentSwimSpeed = 16
local swimVelocity = nil
local swimAttachment = nil

-- Function to set up velocity constraint on character spawn/respawn
local function setupSwimMover(character)
    local rootPart = character:WaitForChild("HumanoidRootPart", 5)
    if not rootPart then return end

    -- Clean up old instances if they exist
    if swimAttachment then swimAttachment:Destroy() end
    if swimVelocity then swimVelocity:Destroy() end

    swimAttachment = Instance.new("Attachment")
    swimAttachment.Name = "SwimAttachment"
    swimAttachment.Parent = rootPart

    swimVelocity = Instance.new("LinearVelocity")
    swimVelocity.Name = "SwimVelocity"
    swimVelocity.Attachment0 = swimAttachment
    swimVelocity.MaxForce = 0 -- Off by default
    swimVelocity.RelativeTo = Enum.ActuatorRelativeTo.World
    swimVelocity.Parent = rootPart
end

-- Track character spawns
if LocalPlayer.Character then setupSwimMover(LocalPlayer.Character) end
LocalPlayer.CharacterAdded:Connect(setupSwimMover)

-- Active swimming loop
RunService.RenderStepped:Connect(function()
    local character = LocalPlayer.Character
    if character then
        local humanoid = character:FindFirstChildOfClass("Humanoid")
        local rootPart = character:FindFirstChild("HumanoidRootPart")
        
        if humanoid and rootPart and swimVelocity then
            if humanoid:GetState() == Enum.HumanoidStateType.Swimming then
                local moveDir = humanoid.MoveDirection
                
                if moveDir.Magnitude > 0 then
                    -- Enable force and drive character in movement direction
                    swimVelocity.MaxForce = 999999
                    swimVelocity.VectorVelocity = moveDir * currentSwimSpeed
                else
                    -- Let Roblox handle idling in water
                    swimVelocity.MaxForce = 0
                end
            else
                -- Disable force when not in water
                swimVelocity.MaxForce = 0
            end
        end
    end
end)

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

local infJumpEnabled = false
local jumpConnection = nil

local Toggle = Tab:Toggle({
    Title = "Infinite Jump",
    Desc = "Jump continuously in the air",
    Default = false,
    Callback = function(state)
        infJumpEnabled = state
        
        -- Clean up existing connection if toggled off
        if jumpConnection then
            jumpConnection:Disconnect()
            jumpConnection = nil
        end
        
        -- Listen for jump key presses when enabled
        if infJumpEnabled then
            jumpConnection = UserInputService.JumpRequest:Connect(function()
                local character = LocalPlayer.Character
                if character then
                    local humanoid = character:FindFirstChildOfClass("Humanoid")
                    if humanoid then
                        humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
                    end
                end
            end)
        end
    end
})

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

local savedCFrame = nil

-- Save Position Button
local SaveButton = Tab:Button({
    Title = "Save Position",
    Desc = "Saves your current location",
    Callback = function()
        local character = LocalPlayer.Character
        if character and character:FindFirstChild("HumanoidRootPart") then
            savedCFrame = character.HumanoidRootPart.CFrame
            print("Position saved at:", savedCFrame.Position)
        end
    end
})

-- Teleport to Position Button
local TPButton = Tab:Button({
    Title = "Teleport to Saved Position",
    Desc = "Teleports you back to your saved location",
    Callback = function()
        if not savedCFrame then
            warn("No position saved yet!")
            return
        end
        
        local character = LocalPlayer.Character
        if character and character:FindFirstChild("HumanoidRootPart") then
            -- PivotTo is the safest method to move full character models
            character:PivotTo(savedCFrame)
        end
    end
})

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

local LocalPlayer = Players.LocalPlayer
local Camera = workspace.CurrentCamera

local flyEnabled = false
local flyConnection = nil
local flySpeed = 50

-- Create Mobile UI Container
local mobileGui = Instance.new("ScreenGui")
mobileGui.Name = "FlyMobileGui"
mobileGui.ResetOnSpawn = false
mobileGui.Enabled = false

-- Try inserting into CoreGui, fallback to PlayerGui
pcall(function()
    mobileGui.Parent = CoreGui
end)
if not mobileGui.Parent then
    mobileGui.Parent = LocalPlayer:WaitForChild("PlayerGui")
end

-- Helper to make mobile buttons
local function createButton(name, text, position)
    local btn = Instance.new("TextButton")
    btn.Name = name
    btn.Text = text
    btn.Size = UDim2.new(0, 60, 0, 60)
    btn.Position = position
    btn.BackgroundColor3 = Color3.fromRGB(30, 30, 30)
    btn.TextColor3 = Color3.fromRGB(255, 255, 255)
    btn.TextSize = 24
    btn.Font = Enum.Font.SourceSansBold
    btn.BackgroundTransparency = 0.3
    btn.Parent = mobileGui
    
    local corner = Instance.new("UICorner")
    corner.CornerRadius = UDim.new(0, 12)
    corner.Parent = btn
    
    return btn
end

-- Up / Down Buttons (Right side of mobile screen)
local upBtn = createButton("UpButton", "▲", UDim2.new(1, -80, 0.5, -70))
local downBtn = createButton("DownButton", "▼", UDim2.new(1, -80, 0.5, 0))

local isMovingUp = false
local isMovingDown = false

upBtn.MouseButton1Down:Connect(function() isMovingUp = true end)
upBtn.MouseButton1Up:Connect(function() isMovingUp = false end)
downBtn.MouseButton1Down:Connect(function() isMovingDown = true end)
downBtn.MouseButton1Up:Connect(function() isMovingDown = false end)

-- Main Fly Toggle
local Toggle = Tab:Toggle({
    Title = "Fly (Mobile Support)",
    Desc = "Fly using Thumbstick + Up/Down buttons",
    Default = false,
    Callback = function(state)
        flyEnabled = state
        mobileGui.Enabled = state
        
        if flyConnection then
            flyConnection:Disconnect()
            flyConnection = nil
        end
        
        local character = LocalPlayer.Character
        if character then
            local humanoid = character:FindFirstChildOfClass("Humanoid")
            local rootPart = character:FindFirstChild("HumanoidRootPart")
            
            if humanoid and rootPart then
                if flyEnabled then
                    humanoid.PlatformStand = true
                    
                    flyConnection = RunService.RenderStepped:Connect(function(dt)
                        local moveDir = Vector3.new(0, 0, 0)
                        
                        -- 1. Mobile Virtual Thumbstick / WASD
                        if humanoid.MoveDirection.Magnitude > 0 then
                            moveDir = moveDir + humanoid.MoveDirection
                        end
                        
                        -- 2. Keyboard PC Fallbacks (E / Q)
                        if UserInputService:IsKeyDown(Enum.KeyCode.E) then moveDir = moveDir + Vector3.new(0, 1, 0) end
                        if UserInputService:IsKeyDown(Enum.KeyCode.Q) then moveDir = moveDir - Vector3.new(0, 1, 0) end
                        
                        -- 3. Mobile Touch Buttons (Up / Down)
                        if isMovingUp then moveDir = moveDir + Vector3.new(0, 1, 0) end
                        if isMovingDown then moveDir = moveDir - Vector3.new(0, 1, 0) end
                        
                        -- 4. Apply Position Shift
                        if moveDir.Magnitude > 0 then
                            rootPart.CFrame = rootPart.CFrame + (moveDir.Unit * (flySpeed * dt))
                        end
                        
                        rootPart.AssemblyLinearVelocity = Vector3.new(0, 0, 0)
                    end)
                else
                    humanoid.PlatformStand = false
                    rootPart.AssemblyLinearVelocity = Vector3.new(0, 0, 0)
                end
            end
        end
    end
})

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local LocalPlayer = Players.LocalPlayer

local platformEnabled = false
local platformPart = nil
local platformConnection = nil

-- Function to create the floating platform
local function createPlatform()
    if platformPart then platformPart:Destroy() end
    
    platformPart = Instance.new("Part")
    platformPart.Name = "AirPlatform"
    platformPart.Size = Vector3.new(6, 1, 6)
    platformPart.Anchored = true
    platformPart.CanCollide = true
    platformPart.Material = Enum.Material.SmoothPlastic
    platformPart.Transparency = 0.5
    platformPart.Color = Color3.fromRGB(0, 170, 255)
    platformPart.Parent = workspace
    
    return platformPart
end

local Toggle = Tab:Toggle({
    Title = "Air Platform",
    Desc = "Spawns a platform under your feet",
    Default = false,
    Callback = function(state)
        platformEnabled = state
        
        -- Clean up existing connection & platform
        if platformConnection then
            platformConnection:Disconnect()
            platformConnection = nil
        end
        if platformPart then
            platformPart:Destroy()
            platformPart = nil
        end
        
        if platformEnabled then
            local platform = createPlatform()
            
            platformConnection = RunService.RenderStepped:Connect(function()
                local character = LocalPlayer.Character
                if character and character:FindFirstChild("HumanoidRootPart") and platform then
                    local rootPart = character.HumanoidRootPart
                    -- Position platform slightly below the character's feet
                    platform.CFrame = CFrame.new(rootPart.Position - Vector3.new(0, 3.5, 0))
                end
            end)
        end
    end
})

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

local function wipeDamageScripts(container)
    if not container then return end
    
    for _, item in ipairs(container:GetDescendants()) do
        -- Check for standard LocalScripts and ModuleScripts running on your character
        if item:IsA("LocalScript") or item:IsA("Script") then
            local scriptName = item.Name:lower()
            
            -- Targeted keywords common in damage/kill scripts
            if scriptName:find("kill") 
                or scriptName:find("damage") 
                or scriptName:find("lava") 
                or scriptName:find("die") 
                or scriptName:find("health") then
                
                item:Destroy()
                print("Destroyed potential kill script:", item:GetFullName())
            end
        end
    end
end

local Toggle = Tab:Toggle({
    Title = "Script-Wipe God Mode",
    Desc = "Deletes client kill/damage scripts attached to character",
    Default = false,
    Callback = function(state)
        if state then
            local character = LocalPlayer.Character
            if character then
                -- Delete scripts inside character, tools, and player scripts
                wipeDamageScripts(character)
                wipeDamageScripts(LocalPlayer:FindFirstChild("PlayerScripts"))
            end
        end
    end
})

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local LocalPlayer = Players.LocalPlayer

-- Create the Visuals Tab (Emoji Removed)
local VisualsTab = Window:Tab({
    Title = "Visuals",
    Icon = "eye" -- Icon property depending on your UI library setup
})

local espEnabled = false
local espConnection = nil

-- Default Player Color (Can be changed dynamically via the Color Picker)
local playerHighlightColor = Color3.fromRGB(0, 255, 100) -- Default Green
local sharkHighlightColor = Color3.fromRGB(255, 0, 0)     -- Static Red for Sharks

-- Color Picker
local ColorPicker = VisualsTab:Colorpicker({
    Title = "Player ESP Color",
    Desc = "Changes the highlight color for players",
    Default = playerHighlightColor,
    Callback = function(selectedColor)
        playerHighlightColor = selectedColor
    end
})

-- Function to update highlights
local function updateESP()
    -- 1. Highlight Players (Uses Color Picker Color)
    for _, player in ipairs(Players:GetPlayers()) do
        if player ~= LocalPlayer and player.Character then
            local char = player.Character
            local highlight = char:FindFirstChild("ESPHighlight")
            
            if espEnabled then
                if not highlight then
                    highlight = Instance.new("Highlight")
                    highlight.Name = "ESPHighlight"
                    highlight.Adornee = char
                    highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
                    highlight.Parent = char
                end
                highlight.FillColor = playerHighlightColor
                highlight.OutlineColor = Color3.fromRGB(255, 255, 255)
                highlight.FillTransparency = 0.5
            else
                if highlight then highlight:Destroy() end
            end
        end
    end

    -- 2. Highlight Sharks (Stays Red)
    for _, object in ipairs(workspace:GetDescendants()) do
        if object:IsA("Model") and object.Name:lower():find("shark") then
            local highlight = object:FindFirstChild("ESPHighlight")
            
            if espEnabled then
                if not highlight then
                    highlight = Instance.new("Highlight")
                    highlight.Name = "ESPHighlight"
                    highlight.Adornee = object
                    highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
                    highlight.Parent = object
                end
                highlight.FillColor = sharkHighlightColor
                highlight.OutlineColor = Color3.fromRGB(255, 255, 255)
                highlight.FillTransparency = 0.4
            else
                if highlight then highlight:Destroy() end
            end
        end
    end
end

-- Cleanup function
local function removeAllESP()
    for _, descendant in ipairs(workspace:GetDescendants()) do
        if descendant.Name == "ESPHighlight" then
            descendant:Destroy()
        end
    end
end

-- ESP Toggle
local Toggle = VisualsTab:Toggle({
    Title = "ESP (Players & Sharks)",
    Desc = "Highlights Players and Sharks through walls",
    Default = false,
    Callback = function(state)
        espEnabled = state
        
        if espConnection then
            espConnection:Disconnect()
            espConnection = nil
        end
        
        if espEnabled then
            espConnection = RunService.RenderStepped:Connect(function()
                updateESP()
            end)
        else
            removeAllESP()
        end
    end
})

----------------------------------------------------------------
-- ANTI-LAG / FPS BOOST
----------------------------------------------------------------
local Lighting = game:GetService("Lighting")
local antiLagEnabled = false
local originalShadows = Lighting.GlobalShadows

local AntiLagToggle = VisualsTab:Toggle({
    Title = "Anti-Lag (FPS Boost)",
    Desc = "Disables heavy effects, shadows, and particles",
    Default = false,
    Callback = function(state)
        antiLagEnabled = state
        
        if antiLagEnabled then
            -- Disable Global Shadows
            Lighting.GlobalShadows = false
            
            -- Lower Terrain Rendering Detail
            if workspace:FindFirstChildOfClass("Terrain") then
                workspace.Terrain.WaterWaveSize = 0
                workspace.Terrain.WaterWaveSpeed = 0
                workspace.Terrain.WaterReflectance = 0
                workspace.Terrain.WaterTransparency = 0
            end
            
            -- Disable heavy particles & post effects
            for _, v in ipairs(workspace:GetDescendants()) do
                if v:IsA("ParticleEmitter") or v:IsA("Smoke") or v:IsA("Fire") or v:IsA("Sparkles") then
                    v.Enabled = false
                elseif v:IsA("PostEffect") or v:IsA("BloomEffect") or v:IsA("BlurEffect") or v:IsA("SunRaysEffect") then
                    v.Enabled = false
                end
            end
        else
            -- Restore Global Shadows & Effects
            Lighting.GlobalShadows = originalShadows
            
            for _, v in ipairs(workspace:GetDescendants()) do
                if v:IsA("ParticleEmitter") or v:IsA("Smoke") or v:IsA("Fire") or v:IsA("Sparkles") then
                    v.Enabled = true
                elseif v:IsA("PostEffect") or v:IsA("BloomEffect") or v:IsA("BlurEffect") or v:IsA("SunRaysEffect") then
                    v.Enabled = true
                end
            end
        end
    end
})

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local LocalPlayer = Players.LocalPlayer

local hitboxEnabled = false
local hitboxConnection = nil
local originalSizes = {} -- Store original sizes to revert back cleanly

local HitboxToggle = VisualsTab:Toggle({
    Title = "Shark Hitbox Expander (6x)",
    Desc = "Multiplies the size of all shark hitboxes by 6",
    Default = false,
    Callback = function(state)
        hitboxEnabled = state
        
        -- Clean up render connection if toggled off
        if hitboxConnection then
            hitboxConnection:Disconnect()
            hitboxConnection = nil
        end
        
        if hitboxEnabled then
            hitboxConnection = RunService.RenderStepped:Connect(function()
                for _, object in ipairs(workspace:GetDescendants()) do
                    if object:IsA("Model") and object.Name:lower():find("shark") then
                        -- Target HumanoidRootPart or PrimaryPart / main BasePart
                        local targetPart = object:FindFirstChild("HumanoidRootPart") 
                            or object.PrimaryPart 
                            or object:FindFirstChildWhichIsA("BasePart")
                            
                        if targetPart then
                            -- Store original size once before expanding
                            if not originalSizes[targetPart] then
                                originalSizes[targetPart] = targetPart.Size
                            end
                            
                            -- Expand hitbox by 6x
                            local origSize = originalSizes[targetPart]
                            targetPart.Size = origSize * 6
                            targetPart.Transparency = 0.7 -- Semi-transparent so you can target easily
                            targetPart.CanCollide = false -- Prevents crashing your boat/character into the huge box
                        end
                    end
                end
            end)
        else
            -- Restore all original hitbox sizes
            for part, origSize in pairs(originalSizes) do
                if part and part.Parent then
                    part.Size = origSize
                    part.Transparency = 0 -- Restore standard visibility
                end
            end
            table.clear(originalSizes)
        end
    end
})

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local VirtualUser = game:GetService("VirtualUser")
local LocalPlayer = Players.LocalPlayer

-- Create Auto-Farm Tab
local FarmTab = Window:Tab({
    Title = "Auto Farm",
    Icon = "bot"
})

local autoFarmEnabled = false
local farmConnection = nil
local antiAfkConnection = nil



-- Safe target search function
local function getSharkTarget()
    for _, object in ipairs(workspace:GetDescendants()) do
        if object:IsA("Model") and object.Name:lower():find("shark") then
            local primary = object.PrimaryPart 
                or object:FindFirstChild("HumanoidRootPart") 
                or object:FindFirstChildWhichIsA("BasePart")
            if primary then
                return primary
            end
        end
    end
    return nil
end

----------------------------------------------------------------
-- ORIGINAL / FAST AUTO FARM (HIGH BAN RISK)
----------------------------------------------------------------
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local VirtualUser = game:GetService("VirtualUser")
local LocalPlayer = Players.LocalPlayer

local autoFarmEnabled = false
local farmConnection = nil
local antiAfkConnection = nil

-- Target search function
local function getSharkTarget()
    for _, object in ipairs(workspace:GetDescendants()) do
        if object:IsA("Model") and object.Name:lower():find("shark") then
            local primary = object.PrimaryPart 
                or object:FindFirstChild("HumanoidRootPart") 
                or object:FindFirstChildWhichIsA("BasePart")
            if primary then
                return primary
            end
        end
    end
    return nil
end

----------------------------------------------------------------
-- WINDUI DIALOG WARNING & AUTO FARM TOGGLE
----------------------------------------------------------------
local autoFarmEnabled = false
local farmConnection = nil

----------------------------------------------------------------
-- WINDUI DIALOG WARNING & AUTO FARM TOGGLE
----------------------------------------------------------------
local autoFarmEnabled = false
local farmConnection = nil

----------------------------------------------------------------
-- AUTO FARM SHARKS (NO DIALOG / INSTANT TOGGLE)
----------------------------------------------------------------
local autoFarmEnabled = false
local farmConnection = nil

local FarmToggle = FarmTab:Toggle({
    Title = "Auto Farm Sharks (Instant TP)",
    Desc = "Instant CFrame TP above shark & continuous fire",
    Value = false,
    Callback = function(state)
        autoFarmEnabled = state
        
        if farmConnection then
            farmConnection:Disconnect()
            farmConnection = nil
        end
        
        if autoFarmEnabled then
            farmConnection = RunService.RenderStepped:Connect(function()
                local char = LocalPlayer.Character
                if not char or not char:FindFirstChild("HumanoidRootPart") then return end
                
                local hrp = char.HumanoidRootPart
                local targetPart = getSharkTarget()
                
                if targetPart then
                    hrp.CFrame = CFrame.new(targetPart.Position + Vector3.new(0, 25, 0), targetPart.Position)
                    local tool = char:FindFirstChildOfClass("Tool")
                    if tool then 
                        tool:Activate() 
                    end
                end
            end)
        end
    end
})
----------------------------------------------------------------
-- AUTO TP TO NEAREST SHARK & AUTO FARM
----------------------------------------------------------------
local RunService = game:GetService("RunService")
local VirtualUser = game:GetService("VirtualUser")
local LocalPlayer = game:GetService("Players").LocalPlayer

local autoFarmEnabled = false
local farmConnection = nil

-- Helper to find the NEAREST active shark root
local function getNearestSharkTarget()
    local char = LocalPlayer.Character
    local hrp = char and char:FindFirstChild("HumanoidRootPart")
    if not hrp then return nil end

    local nearestShark = nil
    local shortestDistance = math.huge

    for _, object in ipairs(workspace:GetDescendants()) do
        if object:IsA("Model") and object.Name:lower():find("shark") then
            local primary = object.PrimaryPart 
                or object:FindFirstChild("HumanoidRootPart") 
                or object:FindFirstChild("Torso")
                or object:FindFirstChildWhichIsA("BasePart")

            if primary then
                local distance = (hrp.Position - primary.Position).Magnitude
                if distance < shortestDistance then
                    shortestDistance = distance
                    nearestShark = primary
                end
            end
        end
    end

    return nearestShark
end

-- Toggle: Auto TP Inside Nearest Shark
local FarmToggle = FarmTab:Toggle({
    Title = "Auto-TP Inside Nearest Shark (safer)",
    Desc = "Finds and teleports you directly inside the closest shark",
    Default = false,
    Callback = function(state)
        autoFarmEnabled = state
        
        if farmConnection then
            farmConnection:Disconnect()
            farmConnection = nil
        end
        
        if autoFarmEnabled then
            farmConnection = RunService.RenderStepped:Connect(function()
                local char = LocalPlayer.Character
                local hrp = char and char:FindFirstChild("HumanoidRootPart")
                local targetPart = getNearestSharkTarget()
                
                if hrp and targetPart then
                    -- Disable collisions temporarily so you don't get flung
                    for _, part in ipairs(char:GetChildren()) do
                        if part:IsA("BasePart") then
                            part.CanCollide = false
                        end
                    end
                    
                    -- Teleport directly into the center of the nearest shark
                    hrp.CFrame = targetPart.CFrame
                    
                    -- Auto-fire held weapon
                    local tool = char:FindFirstChildOfClass("Tool")
                    if tool then
                        tool:Activate()
                    end
                end
            end)
        end
    end
})

-- Toggle: Anti-AFK
local AntiAfkToggle = FarmTab:Toggle({
    Title = "Anti-AFK",
    Desc = "Prevents idle disconnect while farming",
    Default = true,
    Callback = function(state)
        if state then
            antiAfkConnection = LocalPlayer.Idled:Connect(function()
                VirtualUser:Button2Down(Vector2.new(0,0), workspace.CurrentCamera.CFrame)
                task.wait(1)
                VirtualUser:Button2Up(Vector2.new(0,0), workspace.CurrentCamera.CFrame)
            end)
        else
            if antiAfkConnection then
                antiAfkConnection:Disconnect()
                antiAfkConnection = nil
            end
        end
    end
})

----------------------------------------------------------------
-- FORCEFIELD / GOD MODE
----------------------------------------------------------------
local forcefieldEnabled = false
local ffConnection = nil

local ForcefieldToggle = FarmTab:Toggle({
    Title = "Forcefield (God Mode)",
    Desc = "Spawns continuous ForceField protection on your character",
    Default = false,
    Callback = function(state)
        forcefieldEnabled = state
        
        if ffConnection then
            ffConnection:Disconnect()
            ffConnection = nil
        end
        
        if forcefieldEnabled then
            ffConnection = RunService.RenderStepped:Connect(function()
                local char = LocalPlayer.Character
                if char then
                    -- Check if ForceField exists, create one if missing
                    local ff = char:FindFirstChildOfClass("ForceField")
                    if not ff then
                        ff = Instance.new("ForceField")
                        ff.Name = "AutoFarmFF"
                        ff.Parent = char
                    end
                    
                    -- Reset damage tags on Humanoid if present
                    local humanoid = char:FindFirstChildOfClass("Humanoid")
                    if humanoid and humanoid.Health < humanoid.MaxHealth then
                        humanoid.Health = humanoid.MaxHealth
                    end
                end
            end)
        else
            -- Clean up ForceField when disabled
            local char = LocalPlayer.Character
            if char then
                local ff = char:FindFirstChild("AutoFarmFF") or char:FindFirstChildOfClass("ForceField")
                if ff then
                    ff:Destroy()
                end
            end
        end
    end
})

----------------------------------------------------------------
-- BOAT TAB SETUP
----------------------------------------------------------------
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local LocalPlayer = Players.LocalPlayer

local BoatTab = Window:Tab({
    Title = "Boat",
    Icon = "ship" -- Adjust icon name based on your UI library (e.g., "ship", "anchor", etc.)
})

-- State Variables
local godBoatEnabled = false
local boatFlyEnabled = false
local boatSpeed = 100
local godBoatConn = nil
local boatFlyConn = nil

-- Helper function to find player's current seat/vehicle
local function getPlayerVehicle()
    local char = LocalPlayer.Character
    if not char then return nil, nil end
    
    local humanoid = char:FindFirstChildOfClass("Humanoid")
    if not humanoid or not humanoid.SeatPart then return nil, nil end
    
    local seat = humanoid.SeatPart
    local vehicleModel = seat:FindFirstAncestorOfClass("Model")
    return seat, vehicleModel
end

----------------------------------------------------------------
-- 1. GOD BOAT (Indestructible & Anti-Break)
----------------------------------------------------------------
local GodBoatToggle = BoatTab:Toggle({
    Title = "God Boat",
    Desc = "Prevents boat destruction & shark bite damage",
    Default = false,
    Callback = function(state)
        godBoatEnabled = state
        
        if godBoatConn then
            godBoatConn:Disconnect()
            godBoatConn = nil
        end
        
        if godBoatEnabled then
            godBoatConn = RunService.RenderStepped:Connect(function()
                local seat, vehicleModel = getPlayerVehicle()
                if vehicleModel then
                    -- Make all boat parts impossible to destroy or un-weld
                    for _, v in ipairs(vehicleModel:GetDescendants()) do
                        if v:IsA("BasePart") then
                            v.CanCollide = true
                            -- Remove any damage/destroy tags if the game tries to break parts
                            if v:FindFirstChild("Health") then
                                v.Health.Value = 99999
                            end
                        end
                    end
                end
            end)
        end
    end
})

----------------------------------------------------------------
-- UPDATED BOAT SPEED & FLY (PHYSICS OVERRIDE)
----------------------------------------------------------------
local UserInputService = game:GetService("UserInputService")
local RunService = game:GetService("RunService")
local LocalPlayer = game:GetService("Players").LocalPlayer

local boatFlyEnabled = false
local boatSpeed = 100
local flyConnection = nil

-- Helper to find main root part of the boat
local function getBoatRoot()
    local char = LocalPlayer.Character
    if not char then return nil end
    
    local humanoid = char:FindFirstChildOfClass("Humanoid")
    if not humanoid or not humanoid.SeatPart then return nil end
    
    local seat = humanoid.SeatPart
    local vehicleModel = seat:FindFirstAncestorOfClass("Model")
    
    -- Pick the seat or vehicle's PrimaryPart/AssemblyRoot
    return vehicleModel and (vehicleModel.PrimaryPart or seat) or seat
end

----------------------------------------------------------------
-- FIXED BOAT FLY & SPEED SLIDER (BODYVELOCITY METHOD)
----------------------------------------------------------------
local UserInputService = game:GetService("UserInputService")
local RunService = game:GetService("RunService")
local LocalPlayer = game:GetService("Players").LocalPlayer

local boatFlyEnabled = false
local boatSpeed = 100
local flyConnection = nil
local boatBV = nil
local boatGyro = nil

-- Helper to find main root part of the boat
local function getBoatRoot()
    local char = LocalPlayer.Character
    if not char then return nil end
    
    local humanoid = char:FindFirstChildOfClass("Humanoid")
    if not humanoid or not humanoid.SeatPart then return nil end
    
    local seat = humanoid.SeatPart
    local vehicleModel = seat:FindFirstAncestorOfClass("Model")
    
    return vehicleModel and (vehicleModel.PrimaryPart or seat) or seat
end

-- 1. BOAT SPEED SLIDER
local BoatSpeedSlider = BoatTab:Slider({
    Title = "Boat Drive / Fly Speed",
    Min = 50,
    Max = 400,
    Default = 100,
    Callback = function(value)
        boatSpeed = value
    end
})

-- 2. FIXED BOAT FLY TOGGLE
local BoatFlyToggle = BoatTab:Toggle({
    Title = "Boat Fly (Force Velocity)",
    Desc = "Fly boat freely using W, A, S, D + Space (Up) / LeftShift (Down)",
    Default = false,
    Callback = function(state)
        boatFlyEnabled = state
        
        -- Clean up existing physics forces
        if flyConnection then
            flyConnection:Disconnect()
            flyConnection = nil
        end
        if boatBV then boatBV:Destroy() boatBV = nil end
        if boatGyro then boatGyro:Destroy() boatGyro = nil end
        
        if boatFlyEnabled then
            local rootPart = getBoatRoot()
            if not rootPart then return end

            -- Create BodyVelocity to override game vehicle seat limits
            boatBV = Instance.new("BodyVelocity")
            boatBV.MaxForce = Vector3.new(1e6, 1e6, 1e6) -- High force to dominate physics engine
            boatBV.Velocity = Vector3.new(0, 0, 0)
            boatBV.Parent = rootPart

            -- Create BodyGyro to keep boat level while flying
            boatGyro = Instance.new("BodyGyro")
            boatGyro.MaxTorque = Vector3.new(1e6, 1e6, 1e6)
            boatGyro.CFrame = rootPart.CFrame
            boatGyro.Parent = rootPart
            
            flyConnection = RunService.RenderStepped:Connect(function()
                local currentRoot = getBoatRoot()
                if not currentRoot or not boatBV then return end
                
                local camera = workspace.CurrentCamera
                local moveDir = Vector3.new()
                
                -- Key Direction Controls
                if UserInputService:IsKeyDown(Enum.KeyCode.W) then
                    moveDir = moveDir + camera.CFrame.LookVector
                end
                if UserInputService:IsKeyDown(Enum.KeyCode.S) then
                    moveDir = moveDir - camera.CFrame.LookVector
                end
                if UserInputService:IsKeyDown(Enum.KeyCode.A) then
                    moveDir = moveDir - camera.CFrame.RightVector
                end
                if UserInputService:IsKeyDown(Enum.KeyCode.D) then
                    moveDir = moveDir + camera.CFrame.RightVector
                end
                if UserInputService:IsKeyDown(Enum.KeyCode.Space) then
                    moveDir = moveDir + Vector3.new(0, 1, 0)
                end
                if UserInputService:IsKeyDown(Enum.KeyCode.LeftShift) then
                    moveDir = moveDir - Vector3.new(0, 1, 0)
                end
                
                if moveDir.Magnitude > 0 then
                    moveDir = moveDir.Unit
                end
                
                -- Update BodyVelocity live with slider speed value!
                boatBV.Velocity = moveDir * boatSpeed
                
                if boatGyro then
                    boatGyro.CFrame = camera.CFrame
                end
            end)
        end
    end
})
-- 2. FIXED BOAT FLY TOGGLE
local BoatFlyToggle = BoatTab:Toggle({
    Title = "Boat Fly (Fixed)",
    Desc = "Fly boat freely using W, A, S, D + Space (Up) / LeftShift (Down)",
    Default = false,
    Callback = function(state)
        boatFlyEnabled = state
        
        if flyConnection then
            flyConnection:Disconnect()
            flyConnection = nil
        end
        
        if boatFlyEnabled then
            flyConnection = RunService.RenderStepped:Connect(function()
                local rootPart = getBoatRoot()
                if not rootPart then return end
                
                local camera = workspace.CurrentCamera
                local moveDir = Vector3.new()
                
                -- Keys Direction relative to camera
                if UserInputService:IsKeyDown(Enum.KeyCode.W) then
                    moveDir = moveDir + camera.CFrame.LookVector
                end
                if UserInputService:IsKeyDown(Enum.KeyCode.S) then
                    moveDir = moveDir - camera.CFrame.LookVector
                end
                if UserInputService:IsKeyDown(Enum.KeyCode.A) then
                    moveDir = moveDir - camera.CFrame.RightVector
                end
                if UserInputService:IsKeyDown(Enum.KeyCode.D) then
                    moveDir = moveDir + camera.CFrame.RightVector
                end
                if UserInputService:IsKeyDown(Enum.KeyCode.Space) then
                    moveDir = moveDir + Vector3.new(0, 1, 0)
                end
                if UserInputService:IsKeyDown(Enum.KeyCode.LeftShift) then
                    moveDir = moveDir - Vector3.new(0, 1, 0)
                end
                
                -- Normalize direction if moving diagonally so speed stays consistent
                if moveDir.Magnitude > 0 then
                    moveDir = moveDir.Unit
                end
                
                -- Apply force directly to root assembly part
                rootPart.AssemblyLinearVelocity = moveDir * boatSpeed
                rootPart.AssemblyAngularVelocity = Vector3.new(0, 0, 0) -- Prevent aggressive flips/spins
            end)
        else
            local rootPart = getBoatRoot()
            if rootPart then
                rootPart.AssemblyAngularVelocity = Vector3.new(0, 0, 0)
            end
        end
    end
})
----------------------------------------------------------------
-- 3. AUTO FLIP BOAT
----------------------------------------------------------------
local AutoFlipButton = BoatTab:Button({
    Title = "Auto-Flip Boat",
    Desc = "Instantly rights your boat if upside down",
    Callback = function()
        local seat, vehicleModel = getPlayerVehicle()
        local targetPart = seat or (vehicleModel and vehicleModel.PrimaryPart)
        
        if targetPart then
            -- Reset boat rotation upright keeping current position
            local currentPos = targetPart.Position
            targetPart.CFrame = CFrame.new(currentPos + Vector3.new(0, 5, 0)) * CFrame.Angles(0, math.rad(targetPart.Orientation.Y), 0)
            targetPart.AssemblyAngularVelocity = Vector3.new(0, 0, 0)
            targetPart.AssemblyLinearVelocity = Vector3.new(0, 0, 0)
        end
    end
})

----------------------------------------------------------------
-- SHARK TAB SETUP
----------------------------------------------------------------
local SharkTab = Window:Tab({ Title = "Shark Features", Icon = "fish" })

----------------------------------------------------------------
-- SHARK SPEED (INPUT BOX + LIVE VELOCITY)
----------------------------------------------------------------
local sharkSpeedValue = 100
local sharkSpeedEnabled = false
local sharkSpeedConn = nil

-- 1. SHARK SPEED INPUT BOX
SharkTab:Input({
    Title = "Shark Swim Speed",
    Desc = "Type custom swim speed (e.g. 100, 250, 500)",
    Value = "100",
    Placeholder = "Enter speed...",
    Callback = function(text)
        local num = tonumber(text)
        if num then
            sharkSpeedValue = num
        end
    end
})

-- 2. SHARK SPEED TOGGLE
SharkTab:Toggle({
    Title = "Enable Shark Speed Boost",
    Desc = "Forces your shark to swim at the inputted speed",
    Value = false,
    Callback = function(state)
        sharkSpeedEnabled = state
        
        if sharkSpeedConn then
            sharkSpeedConn:Disconnect()
            sharkSpeedConn = nil
        end
        
        if sharkSpeedEnabled then
            sharkSpeedConn = game:GetService("RunService").RenderStepped:Connect(function()
                local char = LocalPlayer.Character
                if not char then return end
                
                local root = char.PrimaryPart or char:FindFirstChild("HumanoidRootPart") or char:FindFirstChildWhichIsA("BasePart")
                local humanoid = char:FindFirstChildOfClass("Humanoid")
                
                if humanoid then
                    humanoid.WalkSpeed = sharkSpeedValue
                end
                
                -- Apply direct movement velocity using the inputted speed
                if root and humanoid and humanoid.MoveDirection.Magnitude > 0 then
                    root.AssemblyLinearVelocity = humanoid.MoveDirection * sharkSpeedValue
                end
            end)
        end
    end
})
-- 2. SHARK SPEED TOGGLE (Applies the speed from slider)
SharkTab:Toggle({
    Title = "Enable Shark Speed Boost",
    Desc = "Forces your shark to swim at the slider speed",
    Value = false,
    Callback = function(state)
        sharkSpeedEnabled = state
        
        if sharkSpeedConn then
            sharkSpeedConn:Disconnect()
            sharkSpeedConn = nil
        end
        
        if sharkSpeedEnabled then
            sharkSpeedConn = game:GetService("RunService").RenderStepped:Connect(function()
                local char = LocalPlayer.Character
                if not char then return end
                
                local root = char.PrimaryPart or char:FindFirstChild("HumanoidRootPart") or char:FindFirstChildWhichIsA("BasePart")
                local humanoid = char:FindFirstChildOfClass("Humanoid")
                
                if humanoid then
                    humanoid.WalkSpeed = sharkSpeedValue
                end
                
                -- Apply direct directional impulse if moving
                if root and humanoid and humanoid.MoveDirection.Magnitude > 0 then
                    root.AssemblyLinearVelocity = humanoid.MoveDirection * sharkSpeedValue
                end
            end)
        end
    end
})

-- 2. SUPER BITE / INSTANT DESTROY BOATS
SharkTab:Toggle({
    Title = "Super Bite (Insta-Break Boats)",
    Desc = "Spams bite hitboxes continuously to instantly destroy boats on touch",
    Value = false,
    Callback = function(state)
        sharkSuperBiteEnabled = state
        if state then
            biteConn = game:GetService("RunService").RenderStepped:Connect(function()
                local char = LocalPlayer.Character
                if not char then return end
                
                -- Fires touch events on nearby boats while playing as shark
                for _, part in ipairs(char:GetDescendants()) do
                    if part:IsA("BasePart") and part.Name:lower():find("jaw") or part.Name:lower():find("teeth") or part.Name:lower():find("head") then
                        for _, boatPart in ipairs(workspace:GetDescendants()) do
                            if boatPart:IsA("BasePart") and boatPart:FindFirstAncestorOfClass("Model") then
                                local model = boatPart:FindFirstAncestorOfClass("Model")
                                if model.Name:lower():find("boat") or model:FindFirstChildOfClass("VehicleSeat") then
                                    if (part.Position - boatPart.Position).Magnitude < 15 then
                                        firetouchinterest(part, boatPart, 0)
                                        firetouchinterest(part, boatPart, 1)
                                    end
                                end
                            end
                        end
                    end
                end
            end)
        else
            if biteConn then
                biteConn:Disconnect()
                biteConn = nil
            end
        end
    end
})

-- 3. TELEPORT TO RANDOM PLAYER (WHEN SHARK)
SharkTab:Button({
    Title = "Teleport to Random Boat / Player",
    Desc = "Instantly teleports your Shark to a survivor",
    Callback = function()
        local char = LocalPlayer.Character
        local hrp = char and (char.PrimaryPart or char:FindFirstChild("HumanoidRootPart"))
        
        if hrp then
            local targets = {}
            for _, player in ipairs(game:GetService("Players"):GetPlayers()) do
                if player ~= LocalPlayer and player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
                    table.insert(targets, player.Character.HumanoidRootPart)
                end
            end
            
            if #targets > 0 then
                local randomTarget = targets[math.random(1, #targets)]
                hrp.CFrame = randomTarget.CFrame * CFrame.new(0, -5, -10) -- Teleports slightly under/behind target
                WindUI:Notify({
                    Title = "Shark Teleport",
                    Content = "Teleported to target!",
                    Duration = 2
                })
            else
                WindUI:Notify({
                    Title = "Shark Teleport",
                    Content = "No valid player targets found!",
                    Duration = 2
                })
            end
        end
    end
})