--i noticed theres a zone to kick u with fake ip,i used this script
local TARGET_SIZE = Vector3.new(
    729.2430419921875,
    403.6414794921875,
    1010.623046875
)
local CHEESE_ZONE_SIZE = Vector3.new(
    120.25,
    201.0500030517578,
    229.45001220703125
)

for _, obj in ipairs(workspace:GetDescendants()) do
    if obj:IsA("BasePart") then
        if (obj.Size - TARGET_SIZE).Magnitude < 0.01 then
            print("Found zone:", obj:GetFullName())
            print("Position:", obj.Position)
            obj:Destroy()
            print("now i js destory an anti-cheat zone")
        end
        if (obj.Size - CHEESE_ZONE_SIZE).Magnitude < 0.01 then
            print("Found zone:", obj:GetFullName())
            print("Position:", obj.Position)
            obj:Destroy()
            print("now i js destory an anti-cheat zone")
        end
    end
end








local Players = game:GetService("Players")

local player = Players.LocalPlayer

--------------------------------------------------
-- CONFIG
--------------------------------------------------

local OFFSET = Vector3.new(0, 2, 0)

local WAIT_AFTER_TELEPORT = 0.15

local WAIT_AFTER_TECHNICAL = 60

-- Number of times each plug is cycled
local PLUG_CYCLES = 5

--------------------------------------------------
-- CHARACTER
--------------------------------------------------

local function getCharacter()
    return player.Character
        or player.CharacterAdded:Wait()
end

local function getRoot()

    local character =
        getCharacter()

    return character:FindFirstChild(
        "HumanoidRootPart"
    ) or character:WaitForChild(
        "HumanoidRootPart"
    )

end

--------------------------------------------------
-- RANDOM ROTATION
--------------------------------------------------

local function randomRotation()

    return CFrame.Angles(
        math.rad(math.random(0, 360)),
        math.rad(math.random(0, 360)),
        math.rad(math.random(0, 360))
    )

end

--------------------------------------------------
-- REGULAR TELEPORT
--------------------------------------------------

local function teleportTo(part)

    if not part then
        return false
    end

    if not part:IsA("BasePart") then
        return false
    end

    local root =
        getRoot()

    if not root then
        return false
    end

    root.AssemblyLinearVelocity =
        Vector3.zero

    root.AssemblyAngularVelocity =
        Vector3.zero

    --------------------------------------------------
    -- REGULAR CFRAME TELEPORT
    --------------------------------------------------

    root.CFrame =
        CFrame.new(
            part.Position + OFFSET
        )
        * randomRotation()

    task.wait(
        WAIT_AFTER_TELEPORT
    )

    root.AssemblyLinearVelocity =
        Vector3.zero

    root.AssemblyAngularVelocity =
        Vector3.zero

    return true

end

--------------------------------------------------
-- FIND A TOUCH PART
--------------------------------------------------

local function getTouchPart(object)

    if not object then
        return nil
    end

    if object:IsA("BasePart") then
        return object
    end

    return object:FindFirstChildWhichIsA(
        "BasePart",
        true
    )

end

--------------------------------------------------
-- GET ALL BASEPARTS
--------------------------------------------------

local function getParts(object)

    local parts = {}

    if not object then
        return parts
    end

    if object:IsA("BasePart") then

        table.insert(
            parts,
            object
        )

    else

        for _, descendant in ipairs(
            object:GetDescendants()
        ) do

            if descendant:IsA("BasePart") then

                table.insert(
                    parts,
                    descendant
                )

            end

        end

    end

    return parts

end

--------------------------------------------------
-- FIND TARGET
--------------------------------------------------

local function findTarget(name)

    local toFind =
        workspace:FindFirstChild(
            "ToFind"
        )

    if not toFind then
        return nil
    end

    --------------------------------------------------
    -- Exact match
    --------------------------------------------------

    local exact =
        toFind:FindFirstChild(
            name,
            true
        )

    if exact then
        return exact
    end

    --------------------------------------------------
    -- Case-insensitive match
    --------------------------------------------------

    local wanted =
        string.lower(name)

    for _, object in ipairs(
        toFind:GetDescendants()
    ) do

        if string.lower(
            object.Name
        ) == wanted then

            return object

        end

    end

    return nil

end

--------------------------------------------------
-- COLLECT ENTIRE PLUG
--------------------------------------------------

local function collectObject(object)

    if not object then
        return false
    end

    local parts =
        getParts(object)

    if #parts == 0 then

        warn(
            "No BaseParts found in:",
            object:GetFullName()
        )

        return false

    end

    --------------------------------------------------
    -- LOOP OVER ENTIRE PLUG
    --------------------------------------------------

    for cycle = 1, PLUG_CYCLES do

        if not object.Parent then
            break
        end

        for _, part in ipairs(parts) do

            if part
                and part.Parent then

                teleportTo(part)

            end

        end

        --------------------------------------------------
        -- Refresh parts
        --------------------------------------------------

        parts =
            getParts(object)

        if #parts == 0 then
            break
        end

    end

    return true

end

--------------------------------------------------
-- COLLECT ALL
--------------------------------------------------

local function collectAll()

    local toFind =
        workspace:FindFirstChild(
            "ToFind"
        )

    if not toFind then

        warn(
            "ToFind not found"
        )

        return

    end

    local children =
        toFind:GetChildren()

    if #children == 0 then

        warn(
            "ToFind is empty"
        )

        return

    end

    --------------------------------------------------
    -- NORMAL COLLECTION
    --
    -- Cheese Plug       -> COLLECT
    -- Technical Plug    -> SKIP
    -- Last collector    -> SAVE FOR LAST
    --------------------------------------------------

    for index, object in ipairs(
        children
    ) do

        local isLast =
            index == #children

        if isLast then
            continue
        end

        --------------------------------------------------
        -- TECHNICAL PLUG
        --------------------------------------------------

        if object.Name ==
            "Technical Plug" then

            print(
                "Skipped Technical Plug:",
                object:GetFullName()
            )

            continue

        end

        --------------------------------------------------
        -- COLLECT EVERYTHING ELSE
        --------------------------------------------------

        local part =
            getTouchPart(object)

        if part
            and part.Parent then

            collectObject(
                object
            )

        end

    end

    --------------------------------------------------
    -- LAST COLLECTOR
    --------------------------------------------------

    local lastCollector =
        children[#children]

    if not lastCollector then
        return
    end

    if not lastCollector.Parent then
        return
    end

    print(
        "Collecting LAST collector:",
        lastCollector:GetFullName()
    )

    collectObject(
        lastCollector
    )

    --------------------------------------------------
    -- TECHNICAL PLUG SPECIAL WAIT
    --------------------------------------------------

    if lastCollector.Name ==
        "Technical Plug" then

        print(
            "Technical Plug completed!"
        )

        print(
            "Waiting",
            WAIT_AFTER_TECHNICAL,
            "seconds..."
        )

        task.wait(
            WAIT_AFTER_TECHNICAL
        )

        print(
            "Technical Plug wait finished."
        )

    end

    print(
        "Collect All finished."
    )

end

--------------------------------------------------
-- COLLECT TARGETTED PLUG
--------------------------------------------------

local function collectTargettedPlug(name)

    name =
        tostring(
            name or ""
        )

    if name == "" then

        warn(
            "Enter a Plug Target first."
        )

        return

    end

    local target =
        findTarget(
            name
        )

    if not target then

        warn(
            "Couldn't find target:",
            name
        )

        return

    end

    print(
        "Found target:",
        target:GetFullName()
    )

    --------------------------------------------------
    -- Collect entire target
    --------------------------------------------------

    collectObject(
        target
    )

    --------------------------------------------------
    -- Technical Plug wait
    --------------------------------------------------

    if target.Name ==
        "Technical Plug" then

        print(
            "Technical Plug completed!"
        )

        print(
            "Waiting",
            WAIT_AFTER_TECHNICAL,
            "seconds..."
        )

        task.wait(
            WAIT_AFTER_TECHNICAL
        )

        print(
            "Technical Plug wait finished."
        )

    end

end

--------------------------------------------------
-- GUI
--------------------------------------------------

local gui =
    Instance.new(
        "ScreenGui"
    )

gui.Name =
    "PlugCollector"

gui.ResetOnSpawn =
    false

gui.Parent =
    player:WaitForChild(
        "PlayerGui"
    )

--------------------------------------------------
-- MAIN FRAME
--------------------------------------------------

local frame =
    Instance.new(
        "Frame"
    )

frame.Name =
    "Main"

frame.Size =
    UDim2.fromOffset(
        320,
        190
    )

frame.Position =
    UDim2.new(
        0,
        20,
        0.5,
        -95
    )

frame.Parent =
    gui

--------------------------------------------------
-- TITLE
--------------------------------------------------

local title =
    Instance.new(
        "TextLabel"
    )

title.Size =
    UDim2.new(
        1,
        0,
        0,
        35
    )

title.Text =
    "Plug Collector"

title.TextScaled =
    true

title.BackgroundTransparency =
    1

title.Parent =
    frame

--------------------------------------------------
-- COLLECT ALL
--------------------------------------------------

local collectAllButton =
    Instance.new(
        "TextButton"
    )

collectAllButton.Size =
    UDim2.new(
        1,
        -20,
        0,
        40
    )

collectAllButton.Position =
    UDim2.fromOffset(
        10,
        40
    )

collectAllButton.Text =
    "Collect All"

collectAllButton.TextScaled =
    true

collectAllButton.Parent =
    frame

collectAllButton.MouseButton1Click:Connect(
    function()

        task.spawn(
            collectAll
        )

    end
)

--------------------------------------------------
-- PLUG TARGET TEXTBOX
--------------------------------------------------

local targetBox =
    Instance.new(
        "TextBox"
    )

targetBox.Size =
    UDim2.new(
        1,
        -20,
        0,
        35
    )

targetBox.Position =
    UDim2.fromOffset(
        10,
        85
    )

targetBox.PlaceholderText =
    "Plug Target"

targetBox.Text =
    ""

targetBox.TextScaled =
    true

targetBox.Parent =
    frame

--------------------------------------------------
-- TARGETTED PLUG
--------------------------------------------------

local targetButton =
    Instance.new(
        "TextButton"
    )

targetButton.Size =
    UDim2.new(
        1,
        -20,
        0,
        40
    )

targetButton.Position =
    UDim2.fromOffset(
        10,
        125
    )

targetButton.Text =
    "Collect Targetted Plug"

targetButton.TextScaled =
    true

targetButton.Parent =
    frame

targetButton.MouseButton1Click:Connect(
    function()

        local name =
            targetBox.Text

        task.spawn(
            function()

                collectTargettedPlug(
                    name
                )

            end
        )

    end
)
print(
    "Plug Collector loaded!"
)

print(
    "PLUG_CYCLES =",
    PLUG_CYCLES
)