1

local dur = tick()

local prefix = "."
local commands, aliases = { }, { }

local ver = "2.7 Version"

local replicatedStorage = game:GetService("ReplicatedStorage")
local textChat = game:GetService("TextChatService")
local players = game:GetService("Players")
local teleport = game:GetService("TeleportService")
local pathfinding = game:GetService("PathfindingService")
local tween = game:GetService("TweenService")

local chatType = textChat.ChatVersion

local accounts = {7977674123, 7611128807, 8021403344}
local disallowed = false
local host = 3405556236
local model = players:GetPlayerByUserId(host)
local localPlayer = players.LocalPlayer
local controllerUser = "Primederrickrose4"

local whitelistedPlayers = {}
local blacklistedPlayers = {}

local bodyguardTarget = nil
local bodyguardingBots = {}
local bodyguardRadius = 10
local detectionRadius = 7
local cooldowns = {}
local tweenService = game:GetService("TweenService")

local standOffset = Vector3.new(-5, 0, 5)
local attackOffset = Vector3.new(0, 0, -15)

local isTowerActive = false
local towerConnections = {}
local noclipBots = {}
local wormConnections = {}
local isWormActive = false
local isTableActive = false
local liftingTargets = {}
local liftConnections = {}
local liftHeight = 0.1
local lifting = false

local loops = {
    invisible = false,
    stare = false,
    ragdoll = false,
    freeze = false,
    jojo = false,
    table = false,
    chair = false
}
local originalPositions = {}
local staringTargets = {}
local ragdollState = {}
local frozenBots = {}

local npcChat = {
    idle = {
        "😃",
        "Hmhmhm 🎶🎵",
        "🤔",
        "Beautifull view.",
        "Just walking.",
        "LaLaLa 🎵",
        "What a nice day.",
        "hmmm",
        "uh",
        ":)"
    },
    freaky = {
        "show me your feets",
        "hehe😏",
        "i feel freaky",
        "i was with didi",
        "come to my basement",
        "aaaaahhh😫😩",
        "😛show me these",
        "sus 😏"
    },
    brainrot = {
        "skibidi dop dop yes yes 🚽",
        "skibidi riz",
        "gyat",
        "mewing rn",
        "im the rizler",
        "ohio fanum tax",
        "only in ohio",
        "mewing 100 streak 🤫🧏‍♂️",
        "im a sigma",
        "i feel sigma",
        "+100 aura 😏",
        "🤫🧏‍♂️",
        "still water 🥶🥶",
        "stop the cap🧢",
        "+1000000 auras"
    },
    damage = {
        "leave me alone",
        "stop it",
        "please stop it",
        "i wish i couldnt feel pain",
        "ouch",
        "ow",
        ":(",
        "ahhhhh"
    },
    freakydamage = {
        "ahhh😫🤭",
        "ow😩",
        "stop it dadi",
        "stop it didi!",
        "dont come to my basement",
        "aaaaahhh😫😩",
        "😏no thanks, stop",
        "😭😫😭"
    },
    brainrotdamage = {
        "skibidi dop dop no no please 🚽",
        "stoo ruining my riz",
        "stappp😠",
        "im mewing!!! stop",
        "my riz 😭",
        "my ohio😩",
        "stop hurting me, only in ohio",
        "you broke my mewing streak 😡",
        "stop it sigma",
        "im not sigma anymore",
        "🤫🧏‍♂️, 😭",
        "stop the cap🧢, i cant take it😢",
        "-1000000 auras"
    }
}

local function find(string)
    if (string == "me" or not string or string == nil) then
        return model
    else
        if not string then
            return
        end

        local saved = {}

        for _, v in ipairs(players:GetPlayers()) do
            if (string.lower(v.Name):match(string.lower(string))) or (string.lower(v.DisplayName):match(string.lower(string))) then
                table.insert(saved, v)
            end
        end

        if #saved > 0 then
            print(type(saved[1]))
            return saved[1]
        else
            return nil
        end
    end
end

local function index()
    local found, indexes = { }, 1

    for i,uID in ipairs(accounts) do
        if players:GetPlayerByUserId(uID) then
            found[indexes] = i
            indexes = indexes + 1
        end
    end
    return found
end

local add = function(aliases, functions)
    for _,name in ipairs(aliases) do
        if (type(name)) == "string" then
            if not (commands[name]) and not (aliases[name]) then
                commands[name] = {
                    functions = functions,
                    aliases = aliases
                }
            else
                aliases[name] = {
                    functions = functions,
                    aliases = aliases
                }
            end
        else
            print("Improper alias type: " .. type(name))
        end
    end
end

local version = function()
    if (chatType) == Enum.ChatVersion.TextChatService then
        return "New"
    else
        return "Legacy"
    end
end

local message = function(res)
    if (version()) == "New" then
        local textChannels = textChat.TextChannels
        local RBX = textChannels.RBXGeneral

        if (RBX) then
            RBX:SendAsync(tostring(res))
        end
    else
        local defaultChatSystemChatEvents = replicatedStorage:FindFirstChild("DefaultChatSystemChatEvents")
        local messageRequest = defaultChatSystemChatEvents:FindFirstChild("SayMessageRequest")

        messageRequest:FireServer(tostring(res), "All")
    end
end

-- Enhanced global helper function to find a player by name or display name
local function findPlayerByName(targetName)
    targetName = string.lower(targetName)  -- Convert targetName to lowercase for case-insensitive matching

    -- Try exact match first
    for _, player in ipairs(players:GetPlayers()) do
        if string.lower(player.Name) == targetName or string.lower(player.DisplayName) == targetName then
            return player
        end
    end

    -- If exact match not found, try partial match
    for _, player in ipairs(players:GetPlayers()) do
        if string.find(string.lower(player.Name), targetName, 1, true) or
           string.find(string.lower(player.DisplayName), targetName, 1, true) then
            return player
        end
    end

    return nil  -- Return nil if no match is found
end

if (model) then
    add({ "performance", "example", "debug" }, function()
        message("Identified in " .. string.format("%.2f", tick() - dur) .. " seconds.")
    end)

    add({ "rejoin", "rj", "rej", "reconnect" }, function()
        local gameId = game.PlaceId
        local jobId = game.JobId

        teleport:TeleportToPlaceInstance(gameId, jobId, localPlayer)
    end)

    add({ "bring", "b" }, function()
        local found = index()
        for i, index in ipairs(found) do
            local bot = players:GetPlayerByUserId(accounts[index])
            if (bot) then
                tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.25, Enum.EasingStyle.Sine), {CFrame = model.Character.HumanoidRootPart.CFrame * CFrame.new((i - (#found / 2) - 0.5) * 4, 0, 3)}):Play()
            end
        end
    end)

-- Assuming these are already initialized somewhere in your code
local whitelistedPlayers = {}
local blacklistedPlayers = {}

-- Function to check if a user is the host
local function isHost(player)
    return player.UserId == model.UserId  -- Ensure the player using the command is the host
end

-- Function to check if a user is whitelisted
local function isWhitelisted(player)
    return whitelistedPlayers[player.UserId] ~= nil
end

-- Function to check if a user is blacklisted
local function isBlacklisted(player)
    return blacklistedPlayers[player.UserId] ~= nil
end

-- Helper function to find a player by name
local function findPlayer(targetName)
    for _, player in ipairs(players:GetPlayers()) do
        if player.Name:lower() == targetName:lower() then
            return player
        end
    end
    return nil
end

-- Whitelist Command: Adds players to the whitelist
add({ "whitelist", "allow" }, function(speaker, targetName)
    local targetPlayer = findPlayer(targetName)
    if targetPlayer then
        -- Add player to the whitelist and remove from the blacklist if present
        whitelistedPlayers[targetPlayer.UserId] = true
        blacklistedPlayers[targetPlayer.UserId] = nil
        message(targetPlayer.Name .. " has been whitelisted.")
        print(targetPlayer.Name .. " has been whitelisted.") -- Debugging output
    else
        message("Player not found.")
    end
end)

-- Blacklist Command: Adds players to the blacklist
add({ "blacklist", "block" }, function(speaker, targetName)
    local targetPlayer = findPlayer(targetName)
    if targetPlayer then
        -- Add player to the blacklist and remove from the whitelist if present
        blacklistedPlayers[targetPlayer.UserId] = true
        whitelistedPlayers[targetPlayer.UserId] = nil
        message(targetPlayer.Name .. " has been blacklisted.")
        print(targetPlayer.Name .. " has been blacklisted.") -- Debugging output
    else
        message("Player not found.")
    end
end)

-- Helper function to process player interaction with bots
function canInteract(player)
    -- Whitelisted players can always interact
    if isWhitelisted(player) then
        return true
    end

    -- Blacklisted players cannot interact
    if isBlacklisted(player) then
        return false
    end

    -- Default behavior for non-listed players (allowed by default if not blacklisted)
    return true
end

local looping = false  -- Flag to control the loop

-- Loopline command to continuously move bots to a specified position
add({ "go" }, function(...)
    local args = {...}
    table.remove(args, 1)  -- Remove "loopline" from the arguments
    local pos = table.concat(args, " "):lower()  -- Get the position (e.g., "left", "right")

    -- Ensure the loop isn't already running
    if looping then
        message("Loopline is already running. Use 'unloopline' to stop it first.")
        return
    end

    looping = true

    local model = players.LocalPlayer  -- Reference point (central model or player)

    coroutine.wrap(function()
        while looping do
            local found = index()  -- Refresh list of active bots
            for i, botIndex in ipairs(found) do
                local bot = players:GetPlayerByUserId(accounts[botIndex])
                if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
                    local offset = i * 4  -- Calculate each bot's offset

                    -- Determine the target CFrame based on the specified position
                    local targetCFrame
                    if pos == "left" or pos == "l" then
                        targetCFrame = model.Character.HumanoidRootPart.CFrame * CFrame.new(-offset, 0, 0)
                    elseif pos == "right" or pos == "r" then
                        targetCFrame = model.Character.HumanoidRootPart.CFrame * CFrame.new(offset, 0, 0)
                    elseif pos == "back" or pos == "b" then
                        targetCFrame = model.Character.HumanoidRootPart.CFrame * CFrame.new(0, 0, offset)
                    elseif pos == "front" or pos == "f" then
                        targetCFrame = model.Character.HumanoidRootPart.CFrame * CFrame.new(0, 0, -offset)
                    end

                    -- Apply the tween if a valid direction is specified
                    if targetCFrame then
                        tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.25, Enum.EasingStyle.Sine), {CFrame = targetCFrame}):Play()
                    end
                end
            end
            wait(1)  -- Adjust the interval between each loop cycle if needed
        end
    end)()
end)

-- Unloopline command to stop the loopline
add({ "ungo" }, function()
    if looping then
        looping = false
    else
        message("Loopline is not running.")
    end
end)

add({ "cmds", "cmd", "commands" }, function()
    message("Classic: chat - dance - bring - re - walk - sky - go - invis - noclip - freeze - npc, brainrot, freaky - hat - lay - nameless - exit")

task.wait(1)
    message("rain - rainloop - bat - lineloop - badword - stand - hollowpurple - kahmehameha - normalpunch - songs - boostfps - online - about - credits")

task.wait(2)
    message("copychat - helicopter - support - ")

task.wait(3)
    message("Targets: fw - look - carpet - worm - liftup - guard - tower - orbit - fling - joe - fling - flingall - whitelist")

task.wait(2)
message("Forms: chair - table - bed - box, lift - triangle - circle - square - tool - ")
end)

add({ "namelesscmds", "namelesscmd", "ncmds" }, function()
    message("Nameless admin, prefix ; , bang, spin, glue, fling, fling2, seizure, commitoof, sit, lay, joke, fcd, fti, fpp, (loops)")
end)

add({ "about", "altcontroller", "altcontrol" }, function()
    message("Alt Control " .. ver .. ", made by Pyst, 200 bobux.")
end)

add({ "songs" }, function()
    message("ksisong - symphony - odetari - rickroll - eminem")
end)

add({ "thickofit", "ksi", "ksisong" }, function()
    message("From screen📱, To the ring🥊, To the pen📝, To the king💎")

task.wait(4)
    message("Where's my crown👑? That's my bling💍")

task.wait(3)
    message("Always drama😢 when I ring🔔")

task.wait(3)
    message("See, I believe that if I see it in my heart♥️")

task.wait(3)
    message("Smash through the ceiling💥 'cause I'm reaching for the stars⭐️")

task.wait(3)
    message("Woah-oh-oh🗣️")

task.wait(4)
    message("This is how the story goes📈")
end)

add({ "symphony", "sing" }, function()
    message("I just🤔")

task.wait(2)
    message("wanna😢")

task.wait(1)
    message("be a part🎶")

task.wait(2)
    message("of your🎵")

task.wait(1)
    message("SYMPHONYYYYYYYYYYYYYYYYYYY !!🎶AHHH")
end)

add({ "odetari", "keepup" }, function()
    message("Give me everything you Took From Me🎵")

task.wait(4)
    message("-give me everything you took from me-")

task.wait(4)
    message("keep up📈")

task.wait(1)
    message("I'm too fast🎶")

task.wait(1)
    message("I'm too fa-ast🎶")

task.wait(2)
    message("Push my foot up on that pedal,")

task.wait(2)
    message("then I'm gone🌚")

task.wait(3)
    message("G-g-g-gone, g-g-gone, gone")
end)

add({ "rickroll", "rickastley" }, function()
    message("Never gonna give you up🔗")

task.wait(3)
    message("Never gonna let you down📉")

task.wait(3)
    message("Never gonna run around and desert you🏃")

task.wait(3)
    message("Never gonna make you cry😭")

task.wait(3)
    message("Never gonna say goodbye👋")

task.wait(3)
    message("Never gonna tell a lie and hurt you🤫🤕")
end)

add({ "eminem", "mms" }, function()
    message("Let me show you the Super sonic speed😏")

task.wait(4)
    message("AHHH🤯")

task.wait(1)
    message("sAanenanenannnnamennenane🗣️")

task.wait(1)
    message("sAmemennenenannennennannenennnamennenane🗣️")

task.wait(1)
    message("saNenenennenemnemennenane🗣️")

task.wait(1)
    message("Sanemanemenammnamnenman🗣️")

task.wait(1)
   message("sanemNenmananmennamnenmmanmmenmmamnemmamemman🗣️")

task.wait(1)
    message("sAmemennenenannennennannenennnamennenane🗣️")
end)

-- Variables to control the lineloop behavior
local lineloopActive = false

-- Lineloop command: Continuously align bots in a line based on the specified direction
add({ "lineloop", "lp" }, function(...)
    local args = {...}
    table.remove(args, 1) -- Remove the command name from arguments

    -- Direction input (e.g., "front", "back", etc.)
    local pos = table.concat(args, " "):lower()

    -- Validate direction
    if pos ~= "front" and pos ~= "f" and pos ~= "back" and pos ~= "b" and pos ~= "left" and pos ~= "l" and pos ~= "right" and pos ~= "r" then
        message("Invalid direction specified. Use: front, back, left, or right.")
        return
    end

    lineloopActive = true

    coroutine.wrap(function()
        while lineloopActive do
            local found = index() -- Get the list of bot accounts
            local hostPlayer = players:GetPlayerByUserId(hostId) -- Assuming hostId is defined somewhere in your code
            if hostPlayer and hostPlayer.Character and hostPlayer.Character:FindFirstChild("HumanoidRootPart") then
                local hostPosition = hostPlayer.Character.HumanoidRootPart.Position -- Use position instead of CFrame

                for i, botIndex in ipairs(found) do
                    local bot = players:GetPlayerByUserId(accounts[botIndex])
                    if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
                        local offset = (i - 1) * 4 -- Adjust spacing between bots
                        local targetPosition

                        -- Determine the target position based on the specified direction
                        if pos == "front" or pos == "f" then
                            targetPosition = hostPosition + hostPlayer.Character.HumanoidRootPart.CFrame.LookVector * -offset
                        elseif pos == "back" or pos == "b" then
                            targetPosition = hostPosition + hostPlayer.Character.HumanoidRootPart.CFrame.LookVector * offset
                        elseif pos == "left" or pos == "l" then
                            targetPosition = hostPosition + hostPlayer.Character.HumanoidRootPart.CFrame.RightVector * -offset
                        elseif pos == "right" or pos == "r" then
                            targetPosition = hostPosition + hostPlayer.Character.HumanoidRootPart.CFrame.RightVector * offset
                        end

                        -- Tween the bot to the calculated position
                        tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.5, Enum.EasingStyle.Sine), {Position = targetPosition}):Play()
                    end
                end
            end
            task.wait(0.5) -- Wait before updating the positions again
        end
    end)()
end)

-- Unlineloop command: Stops the lineloop behavior
add({ "unlineloop", "unlp" }, function()
    lineloopActive = false
end)

-- Default values for orbit speed and offset
local orbitSpeed = 5  -- Default orbit speed
local orbitOffset = 10  -- Default orbit offset (distance from the target)
local orbitActive = false  -- Flag to track if the orbit is active

-- Command to set the target and start the orbit
add({ "orbit" }, function(...)
    local args = {...}
    table.remove(args, 1) -- Remove the command name from arguments

    local target = find(args[1]) -- Locate target using the `find` function
    local found = index()  -- Locate active bots using the `index` function

    if target and target.Character and target.Character:FindFirstChild("HumanoidRootPart") then
        orbitActive = true  -- Activate orbit loop

        -- Orbit coroutine
        coroutine.wrap(function()
            while orbitActive do
                local time = tick()  -- Track time for calculating angle
                local targetPosition = target.Character.HumanoidRootPart.Position -- Update target's position each loop

                for i, botIndex in ipairs(found) do
                    local bot = players:GetPlayerByUserId(accounts[botIndex])
                    if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
                        local angle = (time * orbitSpeed + i * (360 / #found)) % 360
                        local rad = math.rad(angle)
                        local xOffset = math.cos(rad) * orbitOffset
                        local zOffset = math.sin(rad) * orbitOffset
                        local newCFrame = CFrame.new(targetPosition + Vector3.new(xOffset, 0, zOffset))

                        -- Move bot to the calculated orbit position
                        tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.25), { CFrame = newCFrame }):Play()
                    end
                end
                task.wait(0.1)
            end
        end)()
    else
        message("Target not found for orbit.")
    end
end)

-- Command to set the orbit speed
add({ "orbitspeed" }, function(...)
    local args = {...}
    table.remove(args, 1) -- Remove the command name from arguments
    local speed = args[1] -- Get the speed argument

    local newSpeed = tonumber(speed)
    if newSpeed and newSpeed > 0 then
        orbitSpeed = newSpeed
    else
        message("Invalid speed value. Please provide a positive number.")
    end
end)

-- Command to set the orbit offset (distance from the target)
add({ "offset" }, function(...)
    local args = {...}
    table.remove(args, 1) -- Remove the command name from arguments
    local offset = args[1] -- Get the offset argument

    local newOffset = tonumber(offset)
    if newOffset and newOffset > 0 then
        orbitOffset = newOffset
    else
        message("Invalid offset value. Please provide a positive number.")
    end
end)

-- Command to stop the orbit
add({ "unorbit" }, function()
    orbitActive = false
end)

add({ "walk", "w" }, function()
    loops.walk = true

    coroutine.wrap(function()
        while loops.walk do
            local found = index()
            for _, index in ipairs(found) do
                local bot = players:GetPlayerByUserId(accounts[index])
                if bot then
                    local randomDirection = Vector3.new(math.random(-10, 10), 0, math.random(-10, 10))
                    bot.Character.Humanoid:MoveTo(model.Character.HumanoidRootPart.Position + randomDirection)
                end
            end
            task.wait(1)
        end
    end)()
end)

add({ "unwalk", "unw" }, function()
    loops.walk = false
end)

-- Follow command (line formation behind target)
add({ "follow", "fw" }, function(...)
    local args = {...}
    table.remove(args, 1) -- Remove the command name from arguments

    local target = find(args[1]) -- Find the target based on the provided name
    if target then
        loops.follow = true

        coroutine.wrap(function()
            while loops.follow do
                local found = index() -- Get the list of bot accounts
                for i, index in ipairs(found) do
                    local bot = players:GetPlayerByUserId(accounts[index])
                    if bot and bot.Character and target.Character and target.Character:FindFirstChild("HumanoidRootPart") then
                        -- Calculate the position behind the target
                        local offset = (i - (#found / 2) - 0.5) * 4 -- Adjust spacing between bots
                        local targetPosition = target.Character.HumanoidRootPart.Position + Vector3.new(0, 0, -offset) -- Move back along the Z-axis

                        -- Move the bot to the calculated position
                        bot.Character.Humanoid:MoveTo(targetPosition)
                    end
                end
                task.wait(1) -- Wait before the next position update
            end
        end)()
    else
        message("Target not found.")
    end
end)

-- Unfollow command
add({ "unfollow", "unfw" }, function()
    loops.follow = false -- Stop following
end)

-- Sky command
add({ "sky", "skydive" }, function()
    local found = index()
    for i, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot then
            local skyPosition = model.Character.HumanoidRootPart.Position + Vector3.new(0, 100, 0)
            bot.Character:SetPrimaryPartCFrame(CFrame.new(skyPosition))
        end
    end
end) -- HERE HAS been the added line limit YEASSSSSS

-- Function to make bots say random sentences using the message() function
local function randomChat(bot, type)
    if type == "idle" then
        local sentence = npcChat.idle[math.random(1, #npcChat.idle)]
        message(sentence) -- Use message() to chat
    elseif type == "damage" then
        local sentence = npcChat.damage[math.random(1, #npcChat.damage)]
        message(sentence) -- Use message() to chat
    elseif type == "question" then
        local questionResponses = {
            "Idk.",
            "I don't know.",
            "Excuse me, I am unable to answer questions.",
            "Sorry, I cannot answer questions.",
            "I can't answer, sorry.",
            "Unable to answer, sorry.",
            "Apologies, I cannot answer.",
            "That's a good question!",
            "Who knows?",
            "Maybe try asking someone else.",
            "I'm not sure about that.",
            "I wish I could help.",
            "Let me think... Nope, I can't help.",
            "Ask me something else!",
            "Your guess is as good as mine.",
            "I'm just a bot, after all.",
            "My knowledge is limited!",
            "I can't say for certain.",
            "That's beyond my understanding."
        }
        local sentence = questionResponses[math.random(1, #questionResponses)]
        message(sentence) -- Use message() to chat
elseif type == "freaky" then
        local sentence = npcChat.freaky[math.random(1, #npcChat.freaky)]
        message(sentence) -- Use message() to chat
elseif type == "brainrot" then
        local sentence = npcChat.brainrot[math.random(1, #npcChat.brainrot)]
        message(sentence) -- Use message() to chat
elseif type == "freakydamage" then
        local sentence = npcChat.freakydamage[math.random(1, #npcChat.freakydamage)]
        message(sentence) -- Use message() to chat
elseif type == "brainrotdamage" then
        local sentence = npcChat.brainrotdamage[math.random(1, #npcChat.brainrotdamage)]
        message(sentence) -- Use message() to chat
    end
end

-- Function for the bots to stare at players
local function stareAtPlayer(bot, target)
    if target and target.Character and target.Character:FindFirstChild("HumanoidRootPart") then
        -- Calculate the CFrame facing the target's position
        local botRootPart = bot.Character.HumanoidRootPart
        local targetPosition = target.Character.HumanoidRootPart.Position
        local lookAtCFrame = CFrame.new(botRootPart.Position, targetPosition)

        -- Smoothly rotate the bot to face the target
        local tweenInfo = TweenInfo.new(0.5, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
        local tween = tweenService:Create(botRootPart, tweenInfo, {CFrame = lookAtCFrame})
        tween:Play()
    end
end

-- NPC command: Bots walk randomly, jump, and chat
add({ "npc", "npcs" }, function()
    loops.npc = true  -- Flag to keep track of npc behavior

    local found = index() -- Find active bots
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])

        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            local lastChatTime = 0 -- Track last chat time for cooldown
            local stareDistance = 20 -- Distance for bots to notice players

            coroutine.wrap(function()
                while loops.npc do
                    -- Random walking within a 100-stud radius, more frequent (every 3-10 seconds)
                    local randomPos = Vector3.new(
                        bot.Character.HumanoidRootPart.Position.X + math.random(-100, 100),
                        bot.Character.HumanoidRootPart.Position.Y,
                        bot.Character.HumanoidRootPart.Position.Z + math.random(-100, 100)
                    )
                    bot.Character.Humanoid:MoveTo(randomPos)

                    -- Random walk frequency (every 3-10 seconds)
                    task.wait(math.random(3, 10))

                    -- Check for nearby players
                    local playersNearby = {}
                    for _, player in ipairs(players:GetPlayers()) do
                        if player ~= bot and player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
                            local distance = (bot.Character.HumanoidRootPart.Position - player.Character.HumanoidRootPart.Position).Magnitude
                            if distance <= stareDistance then
                                table.insert(playersNearby, player)
                            end
                        end
                    end

                    -- If there are nearby players, stop moving and stare
                    if #playersNearby > 0 then
                        bot.Character.Humanoid:MoveTo(bot.Character.HumanoidRootPart.Position) -- Stop moving
                        for _, player in ipairs(playersNearby) do
                            -- Stare at the first nearby player
                            stareAtPlayer(bot, player)
                        end
                    else
                        -- Random chat every 10-30 seconds, with cooldown
                        if os.clock() - lastChatTime >= math.random(3, 5) then
                            if math.random(1, 3) == 1 then -- Chat sometimes, not every loop
                                local messageType = "idle"
                                if math.random(1, 3) == 1 then -- Random chance for a question response
                                    messageType = "question"
                                end
                                randomChat(bot, messageType)
                                lastChatTime = os.clock() -- Update last chat time
                            end
                        end
                    end

                    -- Random jumping every 15-30 seconds
                    if math.random(1, 2) == 1 then -- 50% chance to jump
                        task.wait(math.random(15, 30))
                        bot.Character.Humanoid.Jump = true -- Jump command
                    end
                end
            end)()  -- Closing the coroutine

            -- Handle damage response (react if damaged)
            bot.Character.Humanoid.HealthChanged:Connect(function(health)
                if loops.npc and health < bot.Character.Humanoid.MaxHealth then
                    -- Say damage response every 5 seconds while bot is being damaged
                    coroutine.wrap(function()
                        while loops.npc and health < bot.Character.Humanoid.MaxHealth do
                            randomChat(bot, "damage")
                            task.wait(5)
                        end
                    end)()  -- Closing the coroutine
                end
            end)  -- Closing the HealthChanged event
        end  -- Closing the if condition
    end  -- Closing the for loop

    message("ok")
end)  -- Closing the add function

-- Unnpc command: Stop the npc behavior and reset bots
add({ "unnpc", "unnpcs", "normal" }, function()
    loops.npc = false  -- Stop the npc loop
    message("Back to normal state.")
end)

-- NPC command: Bots walk randomly, jump, and chat
add({ "freakynpc", "freaky", "freak" }, function()
    print("Starting freakynpc command.")  -- Debug print

    loops.freakynpc = true  -- Flag to keep track of npc behavior
    local found = index() -- Find active bots
    print("Found bots: " .. #found)  -- Print the number of bots found

    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])

        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            print("Starting behavior for bot: " .. tostring(bot.Name))  -- Print bot name

            coroutine.wrap(function()
                while loops.freakynpc do
                    -- Random walking within a 100-stud radius, more frequent (every 3-10 seconds)
                    local randomPos = Vector3.new(
                        bot.Character.HumanoidRootPart.Position.X + math.random(-100, 100),
                        bot.Character.HumanoidRootPart.Position.Y,
                        bot.Character.HumanoidRootPart.Position.Z + math.random(-100, 100)
                    )
                    bot.Character.Humanoid:MoveTo(randomPos)
                    print("Moving bot to position: " .. tostring(randomPos))  -- Print new position

                    -- Random wait frequency (every 3-10 seconds)
                    task.wait(math.random(3, 10))

                    -- Random chat every 10-30 seconds
                    if math.random(1, 3) == 1 then -- Chat sometimes, not every loop
                        randomChat(bot, "freaky")
                        print("Bot " .. tostring(bot.Name) .. " says: freaky")  -- Print chat
                    end

                    -- Random jumping every 15-30 seconds
                    if math.random(1, 2) == 1 then -- 50% chance to jump
                        task.wait(math.random(15, 30))
                        bot.Character.Humanoid.Jump = true -- Jump command
                        print("Bot " .. tostring(bot.Name) .. " jumped.")  -- Print jump action
                    end
                end
            end)()  -- Closing the coroutine

            -- Handle damage response (react if damaged)
            bot.Character.Humanoid.HealthChanged:Connect(function(health)
                if loops.freakynpc and health < bot.Character.Humanoid.MaxHealth then
                    print("Bot " .. tostring(bot.Name) .. " is damaged: " .. health)  -- Print health status
                    coroutine.wrap(function()
                        while loops.freakynpc and health < bot.Character.Humanoid.MaxHealth do
                            randomChat(bot, "freakydamage")
                            print("Bot " .. tostring(bot.Name) .. " says: freakydamage")  -- Print damage chat
                            task.wait(5)
                        end
                    end)()  -- Closing the coroutine
                end
            end)  -- Closing the HealthChanged event
        end  -- Closing the if condition
    end  -- Closing the for loop

    message("ok😏")
    print("Freakynpc command completed.")  -- Debug print
end)  -- Closing the add function

-- Command to start brainrotnpc behavior
add({ "brainrotnpc", "brainrot", "skibidi" }, function()
    print("Starting brainrotnpc command.")  -- Debug print

    loops.brainrotnpc = true  -- Flag to keep track of npc behavior
    local found = index() -- Find active bots
    print("Found bots: " .. #found)  -- Print the number of bots found

    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])

        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            print("Starting behavior for bot: " .. tostring(bot.Name))  -- Print bot name

            coroutine.wrap(function()
                while loops.brainrotnpc do
                    -- Random walking within a 100-stud radius, more frequent (every 3-10 seconds)
                    local randomPos = Vector3.new(
                        bot.Character.HumanoidRootPart.Position.X + math.random(-100, 100),
                        bot.Character.HumanoidRootPart.Position.Y,
                        bot.Character.HumanoidRootPart.Position.Z + math.random(-100, 100)
                    )
                    bot.Character.Humanoid:MoveTo(randomPos)
                    print("Moving bot to position: " .. tostring(randomPos))  -- Print new position

                    -- Random wait frequency (every 3-10 seconds)
                    task.wait(math.random(3, 10))

                    -- Random chat every 10-30 seconds
                    if math.random(1, 3) == 1 then -- Chat sometimes, not every loop
                        randomChat(bot, "brainrot")
                        print("Bot " .. tostring(bot.Name) .. " says: brainrot")  -- Print chat
                    end

                    -- Random jumping every 15-30 seconds
                    if math.random(1, 2) == 1 then -- 50% chance to jump
                        task.wait(math.random(15, 30))
                        bot.Character.Humanoid.Jump = true -- Jump command
                        print("Bot " .. tostring(bot.Name) .. " jumped.")  -- Print jump action
                    end
                end
            end)()  -- Closing the coroutine

            -- Handle damage response (react if damaged)
            bot.Character.Humanoid.HealthChanged:Connect(function(health)
                if loops.brainrotnpc and health < bot.Character.Humanoid.MaxHealth then
                    print("Bot " .. tostring(bot.Name) .. " is damaged: " .. health)  -- Print health status
                    coroutine.wrap(function()
                        while loops.brainrotnpc and health < bot.Character.Humanoid.MaxHealth do
                            randomChat(bot, "brainrotdamage")
                            print("Bot " .. tostring(bot.Name) .. " says: brainrotdamage")  -- Print damage chat
                            task.wait(5)
                        end
                    end)()  -- Closing the coroutine
                end
            end)  -- Closing the HealthChanged event
        end  -- Closing the if condition
    end  -- Closing the for loop

    message("skibidi")
    print("Brainrotnpc command completed.")  -- Debug print
end)  -- Closing the add function

-- Unnpc command: Stop the npc behavior and reset bots
add({ "unfreakynpc", "unfreaky", "unfreak" }, function()
    loops.freakynpc = false  -- Stop the npc loop
    message("Back to normal state.")
end)

-- Unnpc command: Stop the npc behavior and reset bots
add({ "unbrainrotnpc", "unbrainrot", "unskibidi" }, function()
    loops.brainrotnpc = false  -- Stop the npc loop
    message("Back to normal state.")
end)

    add({ "line" }, function(...)
        local args = {...}
        table.remove(args, 1)

        local pos = table.concat(args, " ")

        local found = index()
        for i, index in ipairs(found) do
            local bot = players:GetPlayerByUserId(accounts[index])
            if (bot) then
                if (pos) == "left" or (pos) == "l" then
                    tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.25, Enum.EasingStyle.Sine), {CFrame = model.Character.HumanoidRootPart.CFrame * CFrame.new(-index * 4, 0, 0)}):Play()
                elseif (pos) == "right" or (pos) == "r" then
                    tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.25, Enum.EasingStyle.Sine), {CFrame = model.Character.HumanoidRootPart.CFrame * CFrame.new(index * 4, 0, 0)}):Play()
                elseif (pos) == "back" or (pos) == "b" then
                    tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.25, Enum.EasingStyle.Sine), {CFrame = model.Character.HumanoidRootPart.CFrame * CFrame.new(0, 0, index * 4)}):Play()
                elseif (pos) == "front" or (pos) == "f" then
                    tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.25, Enum.EasingStyle.Sine), {CFrame = model.Character.HumanoidRootPart.CFrame * CFrame.new(0, 0, -index * 4)}):Play()
                end
            end
        end
    end)

-- Helper function to tween bot positions
function tweenBotToPosition(bot, targetPosition, index, totalBots)
    -- Calculate the circular position around the target using angle
    local angle = (index / totalBots) * math.pi * 2
    local offsetX = math.cos(angle) * bodyguardRadius
    local offsetZ = math.sin(angle) * bodyguardRadius
    local newPosition = targetPosition + Vector3.new(offsetX, 0, offsetZ)

    -- Create the tween to smoothly move the bot to the calculated position
    local tween = tweenService:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.25, Enum.EasingStyle.Sine), {CFrame = CFrame.new(newPosition)})
    tween:Play()
end

add({ "bodyguard", "guard" }, function(_, targetName)
    local targetPlayer = find(targetName) -- Find the target player based on the name input
    if not targetPlayer then
        message("Target player not found.")
        return
    end

    bodyguardTarget = targetPlayer -- Set the target player for bodyguarding
    message("Bodyguarding " .. targetPlayer.Name)

    local found = index() -- Get the list of bot accounts
    local numBots = #found -- Number of bots to use for bodyguarding
    local angleStep = (2 * math.pi) / numBots -- Angle increment for bot placement around the target

    -- Coroutine to constantly reposition the bots around the target
    coroutine.wrap(function()
        while bodyguardTarget == targetPlayer do
            for i, index in ipairs(found) do
                local bot = players:GetPlayerByUserId(accounts[index])
                if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
                    local angle = angleStep * (i - 1) -- Calculate the angle for each bot
                    local xOffset = math.cos(angle) * bodyguardRadius
                    local zOffset = math.sin(angle) * bodyguardRadius
                    local newCFrame = targetPlayer.Character.HumanoidRootPart.CFrame * CFrame.new(xOffset, 0, zOffset)

                    -- Tween the bots to smoothly follow the target in a circle
                    tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.5, Enum.EasingStyle.Sine), { CFrame = newCFrame }):Play()
                end
            end
            task.wait(0.5) -- Wait before repositioning the bots again to maintain the circle
        end
    end)()

    -- Threat detection: Bots will react if a player comes too close
    coroutine.wrap(function()
        while bodyguardTarget == targetPlayer do
            for i, index in ipairs(found) do
                local bot = players:GetPlayerByUserId(accounts[index])
                if bot and bot.Character and bot.Character:FindFirstChild("Humanoid") then
                    -- Detect nearby players who are not the target and are within the detection radius
                    for _, otherPlayer in pairs(players:GetPlayers()) do
                        if otherPlayer ~= targetPlayer and otherPlayer.Character and otherPlayer.Character:FindFirstChild("HumanoidRootPart") then
                            local distance = (otherPlayer.Character.HumanoidRootPart.Position - targetPlayer.Character.HumanoidRootPart.Position).Magnitude
                            if distance <= detectionRadius then
                                -- Move the bot to stand between the target and the approaching player
                                local direction = (otherPlayer.Character.HumanoidRootPart.Position - targetPlayer.Character.HumanoidRootPart.Position).unit
                                local guardPosition = targetPlayer.Character.HumanoidRootPart.Position + direction * 5 -- Adjust guard position

                                bot.Character.Humanoid:MoveTo(guardPosition)
                            end
                        end
                    end
                end
            end
            task.wait(1) -- Wait before scanning for threats again
        end
    end)()
end)

-- Command to stop bodyguarding
add({ "unbodyguard", "unguard" }, function()
    bodyguardTarget = nil
    message("No longer bodyguarding.")
end)

-- Invisible Command
add({ "invisible", "invis" }, function()
    loops.invisible = true
    local found = index()
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot then
            originalPositions[bot] = bot.Character.HumanoidRootPart.Position -- Save original position
            local farAwayPos = Vector3.new(0, 10000, 0) -- Far away position above the map
            bot.Character.HumanoidRootPart.CFrame = CFrame.new(farAwayPos)
            bot.Character.Humanoid.PlatformStand = true -- Prevent falling

        end
    end
end)

-- Visible Command
add({ "visible", "vis" }, function()
    loops.invisible = false
    local found = index()
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot then
            bot.Character.HumanoidRootPart.CFrame = CFrame.new(originalPositions[bot]) -- Return to original position
            bot.Character.Humanoid.PlatformStand = false
        end
    end  -- End for loop
end)  -- Closing the add function

-- Require RunService for consistent loop management
local RunService = game:GetService("RunService")

-- Variable to track the connection
local stareConnection

-- Stare at Target Command
add({ "stare", "look" }, function(...)
    local args = {...}
    table.remove(args, 1) -- Remove the command name from arguments

    local target = find(args[1]) -- Find the target based on the provided name
    if target then
        loops.stare = true

        coroutine.wrap(function()
            while loops.stare do
                local found = index() -- Get the list of bot accounts
                for _, index in ipairs(found) do
                    local bot = players:GetPlayerByUserId(accounts[index])
                    if bot and bot.Character and target.Character and target.Character:FindFirstChild("HumanoidRootPart") then
                        -- Calculate the CFrame facing the target's position
                        local botRootPart = bot.Character.HumanoidRootPart
                        local targetPosition = target.Character.HumanoidRootPart.Position
                        local lookAtCFrame = CFrame.new(botRootPart.Position, targetPosition)

                        -- Smoothly rotate the bot to face the target
                        local tweenInfo = TweenInfo.new(0.5, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
                        local tween = tweenService:Create(botRootPart, tweenInfo, {CFrame = lookAtCFrame})
                        tween:Play()
                    end
                end
                task.wait(0.5) -- Wait before updating the stare direction
            end
        end)()
    else
        message("Target not found.")
    end
end)

-- Unstare Command
add({ "unstare", "unlook" }, function()
    loops.stare = false -- Stop staring
end)

-- Ragdoll Command
add({ "ragdoll", "lay" }, function()
    loops.ragdoll = true
    local found = index()
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot then
            ragdollState[bot] = true
            bot.Character.Humanoid.PlatformStand = true -- Make them fall
        end
    end  -- End for loop
end)  -- Closing the add function

-- Unragdoll Command
add({ "unragdoll", "unlay" }, function()
    loops.ragdoll = false
    local found = index()
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot then
            ragdollState[bot] = false
            bot.Character.Humanoid.PlatformStand = false -- Restore control
        end
    end  -- End for loop
end)  -- Closing the add function

-- Freeze Command
add({ "freeze", "fr" }, function()
    loops.freeze = true
    local found = index()
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot then
            frozenBots[bot] = bot.Character.HumanoidRootPart.Position -- Save position
            bot.Character.HumanoidRootPart.Anchored = true -- Freeze in place
        end
    end  -- End for loop
end)  -- Closing the add function

-- Unfreeze Command
add({ "unfreeze", "thaw" }, function()
    loops.freeze = false
    local found = index()
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot then
            bot.Character.HumanoidRootPart.Anchored = false -- Unfreeze
        end
    end  -- End for loop
end)  -- Closing the add function

-- Respawn Command
add({ "respawn", "re" }, function()
    local found = index()
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot then
            originalPositions[bot] = bot.Character.HumanoidRootPart.Position -- Save original position
            bot.Character.Humanoid.Health = 0 -- Reset the bot (kill it)
            task.wait(5) -- Wait for 5 seconds before teleporting back
            bot.Character:SetPrimaryPartCFrame(CFrame.new(originalPositions[bot])) -- Return to original position
        end
    end  -- End for loop
end)  -- Closing the add function

-- JoJo stand follow function
add({ "jojo", "stand" }, function()
    if loops.jojo then return end -- Prevent the loop from restarting if already running
    loops.jojo = true

    -- Store original bot positions
    for _, bot in pairs(accounts) do
        local botPlayer = players:GetPlayerByUserId(bot)
        if botPlayer and botPlayer.Character and botPlayer.Character:FindFirstChild("HumanoidRootPart") then
            originalPositions[bot] = botPlayer.Character.HumanoidRootPart.Position
        end
    end

    -- Start JoJo follow loop
    coroutine.wrap(function()
        while loops.jojo do
            local hostPosition = model.Character.HumanoidRootPart.Position
            local standPosition = hostPosition + standOffset -- Behind and to the right of the host

            -- Move each bot behind and slightly to the right of the host
            for _, bot in pairs(accounts) do
                local botPlayer = players:GetPlayerByUserId(bot)
                if botPlayer and botPlayer.Character and botPlayer.Character:FindFirstChild("HumanoidRootPart") then
                    local botRootPart = botPlayer.Character.HumanoidRootPart

                    -- Tween the bot's position smoothly
                    local tweenInfo = TweenInfo.new(0.5, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
                    local targetPosition = CFrame.new(standPosition)
                    local tween = tweenService:Create(botRootPart, tweenInfo, {CFrame = targetPosition})
                    tween:Play()
                end
            end
            task.wait(0.5) -- Bots adjust position every 0.5 seconds
        end
    end)()
end)

-- Unstand (stop following)
add({ "unjojo", "unstand" }, function()
    if not loops.jojo then return end
    loops.jojo = false

    -- Return bots to their original positions
    for _, bot in pairs(accounts) do
        local botPlayer = players:GetPlayerByUserId(bot)
        if botPlayer and botPlayer.Character and botPlayer.Character:FindFirstChild("HumanoidRootPart") then
            local originalPosition = originalPositions[bot]
            if originalPosition then
                local botRootPart = botPlayer.Character.HumanoidRootPart
                local tweenInfo = TweenInfo.new(0.5, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
                local tween = tweenService:Create(botRootPart, tweenInfo, {Position = originalPosition})
                tween:Play()
            end
        end
    end
end)

-- Function to apply flinging state to a bot
local function applyFlingState(botPlayer)
    if botPlayer and botPlayer.Character and botPlayer.Character:FindFirstChild("HumanoidRootPart") then
        -- Create a BodyVelocity instance to simulate the fling
        local bodyVelocity = Instance.new("BodyVelocity")
        bodyVelocity.MaxForce = Vector3.new(1e6, 1e6, 1e6) -- Apply strong force in all directions
        bodyVelocity.Velocity = Vector3.new(0, 500, 0) -- Set a strong upward velocity for flinging

        -- Add the BodyVelocity to the bot's HumanoidRootPart
        bodyVelocity.Parent = botPlayer.Character.HumanoidRootPart
        return bodyVelocity -- Return the BodyVelocity to remove it later
    end
end

-- Function to remove the flinging state from a bot
local function removeFlingState(bodyVelocity)
    if bodyVelocity then
        bodyVelocity:Destroy() -- Remove the BodyVelocity to stop flinging
    end
end

-- Attack command (move bots further in front of the host and apply flinging state)
add({ "attack", "at" }, function()
    if not loops.jojo then return end

    local hostCharacter = model.Character
    local hostPosition = hostCharacter.HumanoidRootPart.Position
    local hostLookVector = hostCharacter.HumanoidRootPart.CFrame.LookVector  -- Get the direction the host is facing

    local attackDistance = 10  -- Customize this value to control how far in front the bots should go
    local attackPosition = hostPosition + hostLookVector * attackDistance  -- Calculate the attack position in front of the host

    local bodyVelocities = {} -- Table to store the BodyVelocity instances for each bot

    -- Move each bot to the attack position farther in front of the host
    for _, bot in pairs(accounts) do
        local botPlayer = players:GetPlayerByUserId(bot)
        if botPlayer and botPlayer.Character and botPlayer.Character:FindFirstChild("HumanoidRootPart") then
            local botRootPart = botPlayer.Character.HumanoidRootPart
            local targetPosition = attackPosition + Vector3.new(math.random(-2, 2), 0, math.random(-2, 2))  -- Slight random offset for each bot
            local tweenInfo = TweenInfo.new(0.5, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
            local tween = tweenService:Create(botRootPart, tweenInfo, {CFrame = CFrame.new(targetPosition)})
            tween:Play()

            -- Apply flinging state to the bot
            bodyVelocities[bot] = applyFlingState(botPlayer)
        end
    end

    -- Stay in the attack position for 3 seconds while flinging
    task.wait(3)

    -- Remove the flinging state after 3 seconds
    for _, bot in pairs(accounts) do
        removeFlingState(bodyVelocities[bot])
    end

    -- After removing the flinging state, return bots to their follow position
    local standOffset = Vector3.new(0, 0, -5) -- Adjust this to control follow distance behind the host
    local standPosition = hostPosition + hostLookVector * standOffset.Z
    for _, bot in pairs(accounts) do
        local botPlayer = players:GetPlayerByUserId(bot)
        if botPlayer and botPlayer.Character and botPlayer.Character:FindFirstChild("HumanoidRootPart") then
            local botRootPart = botPlayer.Character.HumanoidRootPart
            local tweenInfo = TweenInfo.new(0.5, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
            local tween = tweenService:Create(botRootPart, tweenInfo, {CFrame = CFrame.new(standPosition)})
            tween:Play()
        end
    end
end)

-- Leave Command
add({ "leave", "quit", "exit" }, function()
    local found = index()
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot then
            bot:Kick("Force leave initiated.")
        end
    end
end)

-- HollowPurple/Gojo attack sequence
add({ "hollowpurple", "gojo" }, function()
    local baseplate = Instance.new("Part")
    baseplate.Size = Vector3.new(200, 1, 200) -- Ensure it's large enough for all bots
    baseplate.Position = model.Character.HumanoidRootPart.Position + Vector3.new(0, 300, 0)
    baseplate.Anchored = true
    baseplate.Parent = workspace
    baseplate.Transparency = 1 -- Invisible to the host but exists

    local found = index() -- Get all bots
    local firstBot = players:GetPlayerByUserId(accounts[found[1]])
    local secondBot = players:GetPlayerByUserId(accounts[found[2]])
    local thirdBot = players:GetPlayerByUserId(accounts[found[3]])

    -- step 1: Teleport all bots to the baseplate
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            bot.Character.HumanoidRootPart.CFrame = baseplate.CFrame * CFrame.new((index - (#found / 2)) * 10, 0, 0) -- Spread out on baseplate
        end
    end

    task.wait(2)

    -- step 2: First bot teleporting near the host
    if firstBot and firstBot.Character and firstBot.Character:FindFirstChild("HumanoidRootPart") then
        firstBot.Character.HumanoidRootPart.CFrame = model.Character.HumanoidRootPart.CFrame * CFrame.new(-5, 0, -5) -- Adjusted left and forward
    end

    task.wait(2)

    -- step 3: Second bot teleporting near the host and slow approach
    if secondBot and secondBot.Character and secondBot.Character:FindFirstChild("HumanoidRootPart") then
        secondBot.Character.HumanoidRootPart.CFrame = model.Character.HumanoidRootPart.CFrame * CFrame.new(5, 0, -5) -- Adjusted right and forward
    end

    -- Slow approach of first and second bot towards each other
    spawn(function()
        local approaching = true
        while approaching do
            if firstBot and firstBot.Character and secondBot and secondBot.Character then
                local firstBotPos = firstBot.Character.HumanoidRootPart.Position
                local secondBotPos = secondBot.Character.HumanoidRootPart.Position
                local distance = (firstBotPos - secondBotPos).Magnitude

                -- Move first bot slightly closer to second bot
                firstBot.Character.HumanoidRootPart.CFrame = firstBot.Character.HumanoidRootPart.CFrame:Lerp(
                    CFrame.new(secondBotPos), 0.01)

                -- Move second bot slightly closer to first bot
                secondBot.Character.HumanoidRootPart.CFrame = secondBot.Character.HumanoidRootPart.CFrame:Lerp(
                    CFrame.new(firstBotPos), 0.01)

                -- Stop approaching if they are close enough
                if distance < 1 then
                    approaching = false
                end
            end
            task.wait(0.1) -- Slow approach
        end
    end)

    task.wait(3)

    -- step 4: Spin both the first and second bots during the approach
    local spinLoopRunning = true
    local function spinCharacter(bot)
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            coroutine.wrap(function()
                while spinLoopRunning do
                    bot.Character:SetPrimaryPartCFrame(bot.Character.PrimaryPart.CFrame * CFrame.Angles(0, math.rad(15), 0)) -- Spin
                    task.wait(0.1) -- Fast spinning
                end
            end)()
        end
    end

    spinCharacter(firstBot)
    spinCharacter(secondBot)

    task.wait(3)

    -- step 5: First and second bots return to the baseplate
    if firstBot and firstBot.Character and firstBot.Character:FindFirstChild("HumanoidRootPart") then
        firstBot.Character.HumanoidRootPart.CFrame = baseplate.CFrame * CFrame.new(-5, 0, -5)
    end
    if secondBot and secondBot.Character and secondBot.Character:FindFirstChild("HumanoidRootPart") then
        secondBot.Character.HumanoidRootPart.CFrame = baseplate.CFrame * CFrame.new(5, 0, -5)
    end

    task.wait(1)

    -- step 6: Third bot teleports to the interaction point (where the first two bots were)
    if thirdBot and thirdBot.Character and thirdBot.Character:FindFirstChild("HumanoidRootPart") then
        thirdBot.Character.HumanoidRootPart.CFrame = model.Character.HumanoidRootPart.CFrame * CFrame.new(0, 0, -5) -- Teleport in front
    end

    -- step 7: Spin the third bot during its movement forward
    spinCharacter(thirdBot)

    task.wait(3)

    -- step 8: Third bot moves faster and faster in front (in the direction the host is looking)
    local hostLookVector = model.Character.HumanoidRootPart.CFrame.LookVector -- Get the direction host is looking
    local startPos = thirdBot.Character.HumanoidRootPart.Position
    for i = 1, 8 do
        if thirdBot and thirdBot.Character and thirdBot.Character:FindFirstChild("HumanoidRootPart") then
            thirdBot.Character.HumanoidRootPart.CFrame = CFrame.new(startPos + hostLookVector * i * 10) -- Move forward based on look direction
            task.wait(0.5) -- Speeding up
        end
    end

    -- step 9: After 8 seconds, reset all bots and stop spinning
    task.wait(8)
    spinLoopRunning = false -- Stop the spin loop

    -- Explicitly reset bot CFrames to stop spinning entirely
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            -- Reset rotation by using CFrame without any rotation (LookVector keeps them stable)
            local currentPos = bot.Character.HumanoidRootPart.Position
            bot.Character.HumanoidRootPart.CFrame = CFrame.new(currentPos) -- Reset the orientation
        end
    end
end)

-- Kahmehameha attack sequence
add({ "kahmehameha", "kahmeha", "goku" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there are bots available for the sequence
    if #found >= 1 then
        local host = players.LocalPlayer  -- Assuming this command is triggered by the host
        local hostPosition = host.Character.HumanoidRootPart.CFrame
        local attackInProgress = true

        -- Step 1: Teleport bots in front of the host and start spinning
        for i, botIndex in ipairs(found) do
            local bot = players:GetPlayerByUserId(accounts[botIndex])
            if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
                local botRoot = bot.Character.HumanoidRootPart
                botRoot.CFrame = hostPosition * CFrame.new(0, 0, -3 - i * 3)  -- Position bots in a line in front of host

                -- Start a high-speed spin
                spawn(function()
                    while attackInProgress do
                        botRoot.CFrame = botRoot.CFrame * CFrame.Angles(0, math.rad(90), 0)
                        wait(0.05)  -- Spin speed
                    end
                end)
            end
        end

        -- Step 2: Timed chat sequence
        spawn(function()
            wait(3)
            for _, botIndex in ipairs(found) do
                local bot = players:GetPlayerByUserId(accounts[botIndex])
                if bot then message("kah-") end
            end

            wait(3)
            for _, botIndex in ipairs(found) do
                local bot = players:GetPlayerByUserId(accounts[botIndex])
                if bot then message("meh-") end
            end

            wait(2)
            for _, botIndex in ipairs(found) do
                local bot = players:GetPlayerByUserId(accounts[botIndex])
                if bot then message("ah-") end
            end

            wait(1)
            for _, botIndex in ipairs(found) do
                local bot = players:GetPlayerByUserId(accounts[botIndex])
                if bot then message("meh-") end
            end

            -- Step 3: High-speed dash and scream
            for _, botIndex in ipairs(found) do
                local bot = players:GetPlayerByUserId(accounts[botIndex])
                if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
                    local botRoot = bot.Character.HumanoidRootPart
                    spawn(function()
                        message("AHHHHHHH")
                        local dashDirection = host.Character.HumanoidRootPart.CFrame.LookVector  -- Host's forward direction
                        for i = 1, 80 do
                            botRoot.CFrame = botRoot.CFrame + (dashDirection * 1.5)  -- High-speed forward movement
                            wait(0.05)  -- Adjust for speed
                        end
                    end)
                end
            end

            -- Step 4: Reset after 8 seconds
            wait(8)
            attackInProgress = false  -- Stop spinning

            for _, botIndex in ipairs(found) do
                local bot = players:GetPlayerByUserId(accounts[botIndex])
                if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
                    -- Reset position and orientation
                    bot.Character.HumanoidRootPart.CFrame = hostPosition * CFrame.new(0, 0, -10)  -- Move bots back to a neutral position
                    bot.Character:SetPrimaryPartCFrame(CFrame.new(bot.Character.PrimaryPart.Position))
                end
            end
        end)
    else
        message("Not enough bots available to execute the 'Kahmehameha' command.")
    end
end)

-- Punch configuration
local punchForce = 50  -- Distance bots will be punched back
local downTime = 4     -- Time bots will stay down

-- Command to execute the "normalpunch" or "saitama" command
add({ "normalpunch", "saitama" }, function()
    local found = index()  -- Locate active bots using the `index` function
    local hostPosition = model.Character.HumanoidRootPart.Position  -- Host's position
    local hostCFrame = model.Character.HumanoidRootPart.CFrame  -- Host's CFrame (facing direction)

    -- Store original positions of bots for restoration later
    local originalPositions = {}

    -- Punch coroutine
    for i, botIndex in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[botIndex])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            -- Store the bot's original position
            local originalPosition = bot.Character.HumanoidRootPart.Position
            table.insert(originalPositions, { bot = bot, position = originalPosition })

            coroutine.wrap(function()
                -- Calculate the position in front of the host based on the host's facing direction
                local direction = hostCFrame.LookVector  -- Get the direction the host is facing
                local targetPosition = hostPosition + direction * 4 * (i - 1)  -- Adjust position for each bot

                -- Frame 1: Move the bot to the target position in front of the host
                tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.25), { CFrame = CFrame.new(targetPosition) }):Play()
                task.wait(0.25)

                -- Frame 2: Punch the bot backward with force
                local punchBack = bot.Character.HumanoidRootPart.CFrame * CFrame.new(-direction * punchForce)
                tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.2), { CFrame = punchBack }):Play()
                task.wait(0.2)

                -- Frame 3: Tilt the bot mid-air
                local tiltFrame = punchBack * CFrame.Angles(math.rad(30), 0, 0)
                tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.2), { CFrame = tiltFrame }):Play()
                task.wait(0.2)

                -- Frame 4: Land the bot on the ground
                local landFrame = tiltFrame * CFrame.new(0, -3, 0)  -- Lower bot to simulate falling
                tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.3), { CFrame = landFrame }):Play()
                task.wait(0.3)

                -- Make the bot lay on the ground for `downTime` seconds
                task.wait(downTime)

                -- Stand the bot back up to its original position
                local standUp = bot.Character.HumanoidRootPart.CFrame * CFrame.new(0, 3, 0)  -- Raise the bot back up
                tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.3), { CFrame = standUp }):Play()
            end)()
        end
    end

    -- Restore original positions after the actions
    task.wait(downTime + 1)  -- Wait until all bots have finished their actions
    for _, data in ipairs(originalPositions) do
        local bot = data.bot
        local originalPosition = data.position
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            -- Tween the bot back to its original position
            tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(0.5, Enum.EasingStyle.Sine), { CFrame = CFrame.new(originalPosition) }):Play()
        end
    end
end)

-- Table to store active tower connections
local towerConnections = {}

-- Tower Command with Target Parameter
add({ "tower", "top" }, function(_, targetName)
    if isTowerActive then
        message("Tower is already active.")
        return
    end

    -- Locate the target player using `find` or use the host model if no target is specified
    local targetPlayer = targetName and find(targetName) or model
    local targetCharacter = targetPlayer and targetPlayer.Character

    -- Validate the target character and its position
    if not targetCharacter or not targetCharacter:FindFirstChild("HumanoidRootPart") then
        message("Invalid target for the tower.")
        return
    end

    local targetPosition = targetCharacter.HumanoidRootPart.Position
    isTowerActive = true

    -- Loop through each bot and position them in a stack above the target
    local foundBots = index()
    for i, botId in ipairs(foundBots) do
        local bot = players:GetPlayerByUserId(accounts[botId])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            local botCharacter = bot.Character

            -- Calculate and set the initial tower position for each bot
            local offset = Vector3.new(0, 5 * i, 0)  -- Stack each bot 5 studs above the previous
            botCharacter.HumanoidRootPart.CFrame = targetCharacter.HumanoidRootPart.CFrame * CFrame.new(offset)

            -- Create a BodyPosition instance to keep each bot in place above the target
            local bodyPosition = Instance.new("BodyPosition")
            bodyPosition.MaxForce = Vector3.new(1e6, 1e6, 1e6)  -- Hold bot in place
            bodyPosition.Position = botCharacter.HumanoidRootPart.Position
            bodyPosition.Parent = botCharacter.HumanoidRootPart

            -- Continuously update the bot’s position relative to the target if it moves
            local followConnection = game:GetService("RunService").Heartbeat:Connect(function()
                if isTowerActive and targetCharacter and botCharacter and botCharacter:FindFirstChild("HumanoidRootPart") then
                    bodyPosition.Position = targetCharacter.HumanoidRootPart.Position + offset
                end
            end)

            -- Store connection and body position to reset later
            table.insert(towerConnections, { connection = followConnection, bodyPosition = bodyPosition })
        end
    end

    message("🏢")
end)

-- Untower Command: Dismantle the active tower
add({ "untower", "untop" }, function()
    if not isTowerActive then
        message("No active tower to dismantle.")
        return
    end

    -- Disconnect all connections and remove BodyPosition instances
    for _, botInfo in ipairs(towerConnections) do
        if botInfo.connection then
            botInfo.connection:Disconnect()
        end
        if botInfo.bodyPosition then
            botInfo.bodyPosition:Destroy()
        end
    end

    -- Reset tower state and clear connections
    towerConnections = {}
    isTowerActive = false
end)

-- Command to create the bat-like formation with bots attached to the host's right arm
add({ "bat", "metalbat", "stick" }, function()
    if isBatActive then
        message("Bat formation is already active.")
        return
    end

    local found = index() -- Get the list of bot accounts
    if #found == 0 then
        message("No bots found to form a bat.")
        return
    end

    local hostCharacter = model.Character
    local rightArm = hostCharacter:FindFirstChild("Right Arm") or hostCharacter:FindFirstChild("RightHand")

    if not rightArm then
        message("Host does not have a right arm to attach bots to.")
        return
    end

    isBatActive = true -- Mark the bat formation as active

    -- Loop through all bots and arrange them attached to the host's right arm
    for i, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            local botCharacter = bot.Character

            -- Position the bot relative to the right arm (line them vertically above each other)
            local offset = Vector3.new(0, 3 * i, 0) -- Adjust the vertical spacing (3 studs above each other)
            botCharacter.HumanoidRootPart.CFrame = rightArm.CFrame * CFrame.new(offset)

            -- Create a BodyPosition to lock the bot in place relative to the right arm
            local bodyPosition = Instance.new("BodyPosition")
            bodyPosition.MaxForce = Vector3.new(1e6, 1e6, 1e6) -- Strong enough force to hold the bot in place
            bodyPosition.Position = botCharacter.HumanoidRootPart.Position
            bodyPosition.Parent = botCharacter.HumanoidRootPart

            -- Attach the bot to the right arm so it follows the arm's movements
            local followConnection = game:GetService("RunService").Heartbeat:Connect(function()
                if isBatActive and hostCharacter and botCharacter and botCharacter:FindFirstChild("HumanoidRootPart") and rightArm then
                    bodyPosition.Position = rightArm.Position + rightArm.CFrame:VectorToWorldSpace(Vector3.new(0, 3 * i, 0))
                end
            end)

            -- Store the connection and body position to reset later
            table.insert(batConnections, { connection = followConnection, bodyPosition = bodyPosition })
        end
    end

    message("🔨")
end)

-- Command to cancel the bat formation
add({ "unbat", "unmetalbat", "unstick" }, function()
    if not isBatActive then
        message("No active bat formation to cancel.")
        return
    end

    -- Reset all BodyPositions and disconnect follow connections
    for _, entry in ipairs(batConnections) do
        entry.connection:Disconnect()
        if entry.bodyPosition then
            entry.bodyPosition:Destroy()
        end
    end
    batConnections = {} -- Clear the connection table
    isBatActive = false -- Mark the bat formation as inactive

end)

-- "p", "sus", "what" Command
add({ "p", "carpet", "what" }, function()
    loops.sus = true  -- Activate the "sus" mode

    local found = index()  -- Get list of active bots

    if #found < 3 then
        message("Not enough bots available to form the 'sus' formation.")
        return
    end

    -- Continuously update bots' positions to form the specific layout
    coroutine.wrap(function()
        while loops.sus do
            -- Find the host's torso and legs
            local torso = model.Character:FindFirstChild("Torso") or model.Character:FindFirstChild("UpperTorso")
            local rightLeg = model.Character:FindFirstChild("Right Leg") or model.Character:FindFirstChild("RightUpperLeg")
            local leftLeg = model.Character:FindFirstChild("Left Leg") or model.Character:FindFirstChild("LeftUpperLeg")

            if torso and rightLeg and leftLeg then
                -- Get torso and legs CFrame (position and orientation)
                local torsoCFrame = torso.CFrame
                local rightLegCFrame = rightLeg.CFrame
                local leftLegCFrame = leftLeg.CFrame

                -- Position the first bot between torso and right leg
                local firstBot = players:GetPlayerByUserId(accounts[found[1]])
                if firstBot and firstBot.Character and firstBot.Character:FindFirstChild("HumanoidRootPart") then
                    local botRootPart = firstBot.Character.HumanoidRootPart
                    local botCFrame = torsoCFrame:Lerp(rightLegCFrame, 0.5) * CFrame.new(0, -1, 0)  -- Midpoint between torso and right leg
                    botRootPart.CFrame = botCFrame * CFrame.Angles(math.rad(90), 0, 0)  -- Lay the bot flat (looking down)
                end

                -- Position the second bot between torso and left leg
                local secondBot = players:GetPlayerByUserId(accounts[found[2]])
                if secondBot and secondBot.Character and secondBot.Character:FindFirstChild("HumanoidRootPart") then
                    local botRootPart = secondBot.Character.HumanoidRootPart
                    local botCFrame = torsoCFrame:Lerp(leftLegCFrame, 0.5) * CFrame.new(0, -1, 0)  -- Midpoint between torso and left leg
                    botRootPart.CFrame = botCFrame * CFrame.Angles(math.rad(90), 0, 0)  -- Lay the bot flat (looking down)
                end

                -- Position the third bot horizontally between the heads of the first two bots
                local thirdBot = players:GetPlayerByUserId(accounts[found[3]])
                if thirdBot and thirdBot.Character and thirdBot.Character:FindFirstChild("HumanoidRootPart") then
                    local botRootPart = thirdBot.Character.HumanoidRootPart

                    -- Calculate the midpoint between the first and second bots' positions
                    local firstBotPos = firstBot.Character.HumanoidRootPart.Position
                    local secondBotPos = secondBot.Character.HumanoidRootPart.Position
                    local midPoint = (firstBotPos + secondBotPos) / 2

                    -- Position the third bot's legs between the heads of the first two bots
                    local botCFrame = CFrame.new(midPoint) * CFrame.new(0, -2, 0)  -- Lower it slightly
                    botRootPart.CFrame = botCFrame * CFrame.Angles(math.rad(90), 0, 0)  -- Lay flat, horizontally
                end
            end

            task.wait(0.1)  -- Continuously update every 0.1 seconds
        end
    end)()
end)

-- "unp", "unsus", "unwhat" Command to cancel the sus formation
add({ "unp", "uncarpet", "unwhat" }, function()
    if not loops.sus then
        message("No active 'sus' formation to cancel.")
        return
    end

    loops.sus = false
end)

-- Helper function to enable noclip on a bot
local function enableNoclip(bot)
    if bot and bot.Character then
        noclipBots[bot.UserId] = true -- Mark this bot as being in noclip mode
        -- Disable the collision for all parts except the floor
        for _, part in pairs(bot.Character:GetDescendants()) do
            if part:IsA("BasePart") and part.Name ~= "HumanoidRootPart" then
                part.CanCollide = false
            end
        end
    end
end

-- Helper function to disable noclip on a bot
local function disableNoclip(bot)
    if bot and bot.Character then
        noclipBots[bot.UserId] = nil -- Remove the bot from noclip mode
        -- Re-enable the collision for all parts
        for _, part in pairs(bot.Character:GetDescendants()) do
            if part:IsA("BasePart") and part.Name ~= "HumanoidRootPart" then
                part.CanCollide = true
            end
        end
    end
end

-- "noclip" / "nc" Command: Enables noclip for all bots
add({ "noclip", "nc" }, function()
    local found = index() -- Get the list of bot accounts

    -- Apply noclip to each bot
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot then
            enableNoclip(bot) -- Enable noclip for this bot
        end
    end

    message("Noclip on.")
end)

-- "clip" / "c" Command: Disables noclip for all bots
add({ "clip", "c" }, function()
    local found = index() -- Get the list of bot accounts

    -- Remove noclip from each bot
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot then
            disableNoclip(bot) -- Disable noclip for this bot
        end
    end

    message("Noclip disabled.")
end)

-- Hook into the reset command to automatically disable noclip on reset
local function resetBots()
    local found = index() -- Get the list of bot accounts

    -- Ensure noclip is disabled for all bots upon reset
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot then
            disableNoclip(bot) -- Disable noclip if the bot was in noclip mode
            bot:LoadCharacter() -- Reset the bot
        end
    end

    message("Noclip off.")
end

-- Worm / Slither / Snake Command with a target parameter
local isWormActive = false
local wormConnections = {}

-- Worm/Slither/Snake Formation Command
add({ "worm", "slither", "snake" }, function(targetName)
    if isWormActive then
        return  -- Exit if worm formation is already active
    end

    local found = index()  -- Get the list of bot accounts
    if #found < 2 then
        return  -- Exit if there are not enough bots available (at least 2 to form a chain)
    end

    isWormActive = true

    -- Determine the initial target character using `find`
    local initialTargetPlayer = find(targetName)  -- Locate the target player using `find`
    local initialTargetCharacter = initialTargetPlayer and initialTargetPlayer.Character

    if not initialTargetCharacter or not initialTargetCharacter:FindFirstChild("HumanoidRootPart") then
        isWormActive = false  -- Reset if the target is invalid
        return
    end

    -- Set up each bot to follow its assigned target in a chain formation
    local targetCharacters = {}
    targetCharacters[1] = initialTargetCharacter  -- The first bot follows the initial target

    -- Create a list of bots to follow in sequence
    for i = 1, #found do
        local bot = players:GetPlayerByUserId(accounts[found[i]])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            if i > 1 then
                -- Each bot (after the first) follows the bot ahead in the sequence
                targetCharacters[i] = players:GetPlayerByUserId(accounts[found[i - 1]]).Character
            else
                -- The first bot follows the target player
                targetCharacters[i] = initialTargetCharacter
            end
        end
    end

    -- Continuously make each bot follow its assigned target
    for i, botIndex in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[botIndex])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            local assignedTarget = targetCharacters[i]

            -- Create a loop for each bot to follow its target continuously
            local followConnection = game:GetService("RunService").Heartbeat:Connect(function()
                if isWormActive and assignedTarget and assignedTarget:FindFirstChild("HumanoidRootPart") then
                    local botRootPart = bot.Character.HumanoidRootPart
                    local targetRootPart = assignedTarget.HumanoidRootPart

                    -- Move the bot towards the target's current position, staying slightly behind it
                    local targetPosition = targetRootPart.Position - targetRootPart.CFrame.LookVector * 3  -- Stay 3 studs behind the target
                    botRootPart.CFrame = CFrame.new(targetPosition)  -- Set bot's position directly (or use tween if needed)
                end
            end)

            -- Store the connection to disconnect later
            table.insert(wormConnections, followConnection)
        end
    end
end)

-- Unworm / Unsnake / Unslither Command
add({ "unworm", "unslither", "unsnake" }, function()
    if not isWormActive then
        return  -- Exit if there is no active worm formation
    end

    -- Stop the worm formation by disconnecting all the follow loops
    for _, connection in ipairs(wormConnections) do
        connection:Disconnect()
    end

    -- Clear the connections and deactivate the worm formation
    wormConnections = {}
    isWormActive = false
end)

local joeActive = false  -- Flag to control if the bots should be surrounding

-- Helper function to get a random chat message
local function getRandomJoeMessage()
    local messages = {
        "can i have a joe?",
        "can i have joe?",
        "can i hav a joe?",
        "can i heve a joe?"
    }
    return messages[math.random(#messages)]
end

-- Joe formation command
add({ "joe", "canihavejoe" }, function(targetName)
    local found = index()  -- Locate active bots using the `index` function
    local target = find(targetName)  -- Use the `find` function to locate the target

    if target and target.Character and target.Character:FindFirstChild("HumanoidRootPart") and #found >= 1 then
        local targetPosition = target.Character.HumanoidRootPart.Position
        joeActive = true

        -- Step 1: Position bots in a circular formation around the target
        for i, botIndex in ipairs(found) do
            local bot = players:GetPlayerByUserId(accounts[botIndex])
            if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
                local botRoot = bot.Character.HumanoidRootPart
                local angle = (2 * math.pi / #found) * i  -- Calculate angle for each bot

                -- Determine position in circle
                local xOffset = math.cos(angle) * 6  -- Radius of 6 studs
                local zOffset = math.sin(angle) * 6
                local targetPositionCFrame = CFrame.new(targetPosition + Vector3.new(xOffset, 0, zOffset))

                -- Move bot to the circle position
                tween:Create(botRoot, TweenInfo.new(2, Enum.EasingStyle.Linear), {CFrame = targetPositionCFrame}):Play()

                -- Make bot face the target
                botRoot.CFrame = CFrame.new(botRoot.Position, targetPosition)
            end
        end

        -- Step 2: Bots randomly chat messages every 5-15 seconds
        spawn(function()
            while joeActive do
                wait(math.random(5, 15))
                if not joeActive then break end  -- Exit if unjoe/stopjoe is called

                -- Pick a random bot to chat
                local randomBotIndex = found[math.random(#found)]
                local randomBot = players:GetPlayerByUserId(accounts[randomBotIndex])

                if randomBot then
                    message(getRandomJoeMessage())  -- Only chat the random message, without bot's name
                end
            end
        end)
    else
        message("Target not found or not specified.")
    end
end)

-- Unjoe/Stopjoe command to cancel the joe formation
add({ "unjoe", "stopjoe" }, function()
    joeActive = false  -- Stop the active Joe formation
    local found = index()

    -- Reset each bot's position and orientation
    for _, botIndex in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[botIndex])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            -- Cancel any active tween to allow them to reset
            tween:Create(bot.Character.HumanoidRootPart, TweenInfo.new(1, Enum.EasingStyle.Linear), {CFrame = bot.Character.HumanoidRootPart.CFrame}):Cancel()
        end
    end

    message("i need a joe")  -- Message when 'joe' is canceled
end)

-- Rain Command
add({ "rain", "raining", "partfall" }, function()
    local hostPlayer = game.Players.LocalPlayer -- Get the player who invoked the command

    if not hostPlayer or not hostPlayer.Character or not hostPlayer.Character:FindFirstChild("HumanoidRootPart") then
        message("Host not found.")
        return
    end

    local found = index() -- Get the list of bot accounts
    if #found < 1 then
        message("No bots available.")
        return
    end

    -- Teleport bots above the host in a line formation
    local hostPosition = hostPlayer.Character.HumanoidRootPart.Position -- Get host position
    for i, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            -- Calculate the position above the host in a line formation
            local offset = (i - (#found / 2) - 0.5) * 4 -- Adjust spacing between bots
            local skyPosition = hostPosition + Vector3.new(offset, 100, 0) -- 100 studs above the host

            -- Teleport the bot to the calculated position
            bot.Character:SetPrimaryPartCFrame(CFrame.new(skyPosition))

            -- Reset the bot's character by setting Humanoid health to 0
            local humanoid = bot.Character:FindFirstChild("Humanoid")
            if humanoid then
                humanoid.Health = 0
            end
        end
    end
end)

-- Rainloop / Looprain Command
add({ "rainloop", "looprain" }, function()
    local hostPlayer = game.Players.LocalPlayer -- Get the player who invoked the command

    if not hostPlayer or not hostPlayer.Character or not hostPlayer.Character:FindFirstChild("HumanoidRootPart") then
        message("Host not found.")
        return
    end

    local found = index() -- Get the list of bot accounts
    if #found < 1 then
        message("No bots available.")
        return
    end

    loops.rain = true -- Flag to track the rain loop

    -- Continuously teleport bots above the host
    coroutine.wrap(function()
        while loops.rain do
            local hostPosition = hostPlayer.Character.HumanoidRootPart.Position -- Get host position
            for i, index in ipairs(found) do
                local bot = players:GetPlayerByUserId(accounts[index])
                if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
                    -- Calculate the position above the host in a line formation
                    local offset = (i - (#found / 2) - 0.5) * 4 -- Adjust spacing between bots
                    local skyPosition = hostPosition + Vector3.new(offset, 100, 0) -- 100 studs above the host

                    -- Teleport the bot to the calculated position
                    bot.Character:SetPrimaryPartCFrame(CFrame.new(skyPosition))
                end
            end

            task.wait(1) -- Wait time before the next teleportation
        end
    end)()

    -- Check for respawned bots and continue the loop
    local function checkForRespawns()
        while loops.rain do
            task.wait(1) -- Check every second
            for _, index in ipairs(found) do
                local bot = players:GetPlayerByUserId(accounts[index])
                if bot and bot.Character then
                    -- If the bot is not alive, restart the loop
                    if not bot.Character:FindFirstChild("Humanoid") or bot.Character.Humanoid.Health <= 0 then
                        bot.CharacterAdded:Wait() -- Wait for the bot to respawn
                    end
                end
            end
        end
    end

    -- Start checking for respawns
    coroutine.wrap(checkForRespawns)()
end)

-- Unrain / Unrainloop / Unlooprain Command
add({ "unrain", "unrainloop", "unlooprain" }, function()
    if not loops.rain then
        message("No rain loop is active.")
        return
    end

    loops.rain = false
end)

-- Table to store connections for chat copying
local chatCopyConnections = {}
local copyChatActive = false

-- Command to enable chat copying from the specified target
add({ "copychat", "chatcopy" }, function(...)
    local args = {...}
    table.remove(args, 1) -- Remove the command name from arguments

    -- Locate target using the `find` function
    local targetPlayer = find(args[1])

    -- Validate the target player
    if not targetPlayer then
        message("Target player not found.")
        return
    end

    -- Clear any existing chat copying connections
    for _, conn in ipairs(chatCopyConnections) do
        conn:Disconnect()
    end
    chatCopyConnections = {}
    copyChatActive = true

    -- Listen for the target player's chat messages
    local connection = targetPlayer.Chatted:Connect(function(message)
        if copyChatActive then
            -- Make each bot chat the same message
            local foundBots = index()
            for _, botIndex in ipairs(foundBots) do
                local bot = players:GetPlayerByUserId(accounts[botIndex])
                if bot then
                    bot:Chat(message)
                end
            end
        end
    end)

    -- Store the connection so it can be disconnected later
    table.insert(chatCopyConnections, connection)
end)

-- Command to disable chat copying
add({ "uncopychat", "unchatcopy" }, function()
    if not copyChatActive then
        message("Chat copying is not active.")
        return
    end

    -- Disconnect all chat copying connections
    for _, conn in ipairs(chatCopyConnections) do
        conn:Disconnect()
    end
    chatCopyConnections = {}
    copyChatActive = false
end)

-- Variables to control rotor behavior
local rotorActive = false
local rotorConnections = {}

-- Rotor command: Makes bots spin in a line formation, imitating a rotor
add({ "rotor", "helicopter" }, function()
    if rotorActive then
        message("Rotor is already active.")
        return
    end

    rotorActive = true

    -- Initialize the rotor effect
    coroutine.wrap(function()
        local foundBots = index() -- Get the list of active bot accounts
        local hostPlayer = players:GetPlayerByUserId(hostId) -- Assuming hostId is defined
        if not hostPlayer or not hostPlayer.Character or not hostPlayer.Character:FindFirstChild("HumanoidRootPart") then
            message("Host player not found.")
            return
        end

        -- Get the initial position and orientation for the line
        local hostCFrame = hostPlayer.Character.HumanoidRootPart.CFrame
        local spacing = 4 -- Spacing between each bot in the line

        -- Setup each bot in a line formation and continuously rotate them
        for i, botIndex in ipairs(foundBots) do
            local bot = players:GetPlayerByUserId(accounts[botIndex])
            if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
                local botCharacter = bot.Character
                local offset = (i - 1) * spacing -- Adjust each bot's position in the line
                local targetPosition = hostCFrame * CFrame.new(0, 0, offset)

                -- Set bot to horizontal line position
                botCharacter.HumanoidRootPart.CFrame = targetPosition

                -- Spin the bot rapidly in place
                local connection = game:GetService("RunService").Heartbeat:Connect(function()
                    if rotorActive then
                        local rotation = CFrame.Angles(0, math.rad(45), 0) -- Set rotation speed (e.g., 45 degrees per frame)
                        botCharacter.HumanoidRootPart.CFrame = botCharacter.HumanoidRootPart.CFrame * rotation
                    end
                end)

                -- Store connection for later disconnection
                table.insert(rotorConnections, connection)
            end
        end
    end)()
end)

-- Unrotor command: Stops the rotor effect
add({ "unrotor", "unhelicopter" }, function()
    if not rotorActive then
        message("Rotor is not active.")
        return
    end

    -- Disconnect all rotor connections to stop spinning
    for _, conn in ipairs(rotorConnections) do
        conn:Disconnect()
    end
    rotorConnections = {}
    rotorActive = false
end)

-- Function to check if lifting is in progress
local function isLifting(targetPlayer)
    return liftingTargets[targetPlayer.UserId] ~= nil
end

-- Lift Up Command: Makes bots lift under the specified target
add({ "liftup", "goup", "lf" }, function(_, targetName)
    -- Locate the target player using the `find` method
    local targetPlayer = find(targetName)
    if not targetPlayer or not targetPlayer.Character or not targetPlayer.Character:FindFirstChild("HumanoidRootPart") then
        message("Target player not found or does not have a character.")
        return
    end

    -- Check if bots are already lifting this target
    if liftingTargets[targetPlayer.UserId] then
        message("Already lifting this target.")
        return
    end

    -- Mark the target as currently being lifted
    liftingTargets[targetPlayer.UserId] = true

    -- List of bots to arrange in formation under the target
    local foundBots = index()
    local targetPosition = targetPlayer.Character.HumanoidRootPart.Position

    -- Loop to place each bot under the target
    for i, botId in ipairs(foundBots) do
        local bot = players:GetPlayerByUserId(accounts[botId])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            -- Arrange bots in a line beneath the target
            local botPosition = targetPosition + Vector3.new(0, -5, (i - 1) * 3)  -- Adjust vertical and spacing
            bot.Character:SetPrimaryPartCFrame(CFrame.new(botPosition) * CFrame.Angles(math.rad(90), 0, 0))
            bot.Character.HumanoidRootPart.Anchored = true

            -- Heartbeat connection for lifting
            local connection = game:GetService("RunService").Heartbeat:Connect(function()
                if liftingTargets[targetPlayer.UserId] then
                    -- Smooth lifting movement for each bot
                    local botRootPart = bot.Character.HumanoidRootPart
                    bot.Character:SetPrimaryPartCFrame(botRootPart.CFrame + Vector3.new(0, 0.1, 0))  -- Adjust lift speed
                end
            end)

            -- Store connection to disconnect later
            table.insert(liftConnections, connection)
        end
    end
end)

-- Unlift Command: Stops lifting bots under a specific target
add({ "unliftup", "ungoup", "unlf" }, function(_, targetName)
    -- Find the target player using the `find` method
    local targetPlayer = find(targetName)
    if not targetPlayer or not liftingTargets[targetPlayer.UserId] then
        message("No lifting in progress for this target.")
        return
    end

    -- Stop lifting for this target
    liftingTargets[targetPlayer.UserId] = nil

    -- Disconnect all connections for bots lifting this target
    for _, connection in ipairs(liftConnections) do
        connection:Disconnect()
    end
    liftConnections = {}

    -- Reset bots' anchored status
    local foundBots = index()
    for _, botId in ipairs(foundBots) do
        local bot = players:GetPlayerByUserId(accounts[botId])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            bot.Character.HumanoidRootPart.Anchored = false
        end
    end
end)

-- Define the untable command
add({ "untable" }, function()
    local found = index()  -- Get the indices of the bots
    if #found < 3 then
        print("Not enough bots to execute untable command.")
        return
    end

    local bot3 = players:GetPlayerByUserId(accounts[found[3]])  -- Get the third bot

    if bot3 and bot3.Character then
        -- Remove BodyPosition and BodyGyro to stop floating
        for _, v in pairs(bot3.Character.HumanoidRootPart:GetChildren()) do
            if v:IsA("BodyPosition") or v:IsA("BodyGyro") then
                v:Destroy()  -- Remove them to cancel the floating effect
            end
        end
    end
end)

-- Add the chair command
add({ "chair" }, function()
    local found = index()  -- Get the indices of the bots
    if #found < 2 then
        print("Not enough bots to execute chair command.")
        return
    end

    local host = game.Players.LocalPlayer  -- Assuming the host is the local player
    local bot1 = players:GetPlayerByUserId(accounts[found[1]])
    local bot2 = players:GetPlayerByUserId(accounts[found[2]])

    if bot1 and bot1.Character and bot2 and bot2.Character then
        -- Teleport both bots in front of the host
        local hostPosition = host.Character.HumanoidRootPart.Position
        local teleportOffset = host.Character.HumanoidRootPart.CFrame.LookVector * 5  -- Teleport in front of the host
        bot1.Character:SetPrimaryPartCFrame(CFrame.new(hostPosition + teleportOffset))
        bot2.Character:SetPrimaryPartCFrame(CFrame.new(hostPosition + teleportOffset))

        -- Make bot1 lay down
        bot1.Character.Humanoid:MoveTo(bot1.Character.HumanoidRootPart.Position)  -- Ensure the bot is at its current position
        bot1.Character.Humanoid.Sit = true  -- Make the first bot sit (which we will use to lay it down)
        bot1.Character:SetPrimaryPartCFrame(CFrame.new(bot1.Character.HumanoidRootPart.Position) * CFrame.Angles(-math.pi / 2, 0, 0))  -- Lay it down facing down
        bot1.Character.Humanoid.PlatformStand = true  -- Fix its position so it doesn't move

        -- Make bot2 stand on bot1's head
        bot2.Character:SetPrimaryPartCFrame(bot1.Character.PrimaryPart.CFrame * CFrame.new(0, 2, 0))  -- Position it on top of bot1's head
        bot2.Character.Humanoid.PlatformStand = true  -- Fix bot2's position as well
    end
end)

-- Add the unchair command
add({ "unchair" }, function()
    local found = index()  -- Get the indices of the bots
    if #found < 2 then
        print("Not enough bots to execute unchair command.")
        return
    end

    local bot1 = players:GetPlayerByUserId(accounts[found[1]])
    local bot2 = players:GetPlayerByUserId(accounts[found[2]])

    if bot1 and bot1.Character and bot2 and bot2.Character then
        -- Unlay bot1
        bot1.Character.Humanoid.PlatformStand = false  -- Allow movement again
        bot1.Character.Humanoid.Sit = false  -- Make the bot stand again
        bot1.Character:SetPrimaryPartCFrame(CFrame.new(bot1.Character.HumanoidRootPart.Position.X, bot1.Character.HumanoidRootPart.Position.Y + 2, bot1.Character.HumanoidRootPart.Position.Z))  -- Adjust position slightly above ground

        -- Unstand bot2
        bot2.Character.Humanoid.PlatformStand = false  -- Allow movement again
        bot2.Character:SetPrimaryPartCFrame(CFrame.new(bot2.Character.HumanoidRootPart.Position.X, bot2.Character.HumanoidRootPart.Position.Y + 2, bot2.Character.HumanoidRootPart.Position.Z))  -- Adjust position slightly above ground
    end
end)

add({ "bed" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Reference to the host's position as the starting point of the line
    local host = players.LocalPlayer
    local hostPosition = host.Character.HumanoidRootPart.CFrame

    -- Iterate over each bot and position them in a line
    for i, botIndex in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[botIndex])

        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            -- Calculate the bot's position based on its index in the line
            local offset = i * 4  -- Distance between each bot
            local targetPosition = hostPosition * CFrame.new(0, 0, -offset)

            -- Position the bot at the calculated position with a laying-down orientation
            bot.Character.HumanoidRootPart.CFrame = targetPosition * CFrame.Angles(math.rad(90), 0, 0)
        end
    end
end)

add({ "unbed" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Reset each bot to an upright position
    for i, botIndex in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[botIndex])

        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            -- Reset the bot's orientation to standing (upright position)
            bot.Character.HumanoidRootPart.CFrame = bot.Character.HumanoidRootPart.CFrame * CFrame.Angles(math.rad(-90), 0, 0)
        end
    end
end)

-- Triangle Command: Positions bots in a triangle formation around the host
add({ "triangle" }, function(speaker)
    local found = index() -- Get the relevant bot indexes
    local hostPlayer = players:GetPlayerByUserId(speaker.UserId) -- Get the speaker as host

    if hostPlayer and hostPlayer.Character and hostPlayer.Character:FindFirstChild("HumanoidRootPart") and #found >= 3 then
        local hostPosition = hostPlayer.Character.HumanoidRootPart.Position

        -- Define triangle positions around the host
        local distance = 5 -- Adjust distance as needed
        local positions = {
            hostPosition + Vector3.new(-distance, 0, -distance), -- Bottom left
            hostPosition + Vector3.new(distance, 0, -distance),  -- Bottom right
            hostPosition + Vector3.new(0, 0, distance)           -- Top
        }

        -- Place each bot at a triangle vertex
        for i = 1, 3 do
            local bot = players:GetPlayerByUserId(accounts[found[i]])
            if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
                bot.Character:SetPrimaryPartCFrame(CFrame.new(positions[i])) -- Set position
                bot.Character.HumanoidRootPart.Anchored = true -- Anchor in place
            end
        end
        message("🔺 Triangle formation active.")
    else
        message("Need at least 3 bots for a triangle formation.")
    end
end)

-- Square Command: Positions bots in a square formation around the host
add({ "square" }, function(speaker)
    local found = index() -- Get the relevant bot indexes
    local hostPlayer = players:GetPlayerByUserId(speaker.UserId) -- Get the speaker as host

    if hostPlayer and hostPlayer.Character and hostPlayer.Character:FindFirstChild("HumanoidRootPart") and #found >= 4 then
        local hostPosition = hostPlayer.Character.HumanoidRootPart.Position

        -- Define square positions around the host
        local distance = 5 -- Adjust distance as needed
        local positions = {
            hostPosition + Vector3.new(-distance, 0, -distance), -- Bottom left
            hostPosition + Vector3.new(distance, 0, -distance),  -- Bottom right
            hostPosition + Vector3.new(-distance, 0, distance),  -- Top left
            hostPosition + Vector3.new(distance, 0, distance)    -- Top right
        }

        -- Place each bot at a square vertex
        for i = 1, 4 do
            local bot = players:GetPlayerByUserId(accounts[found[i]])
            if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
                bot.Character:SetPrimaryPartCFrame(CFrame.new(positions[i])) -- Set position
                bot.Character.HumanoidRootPart.Anchored = true -- Anchor in place
            end
        end
        message("🟥 Square formation active.")
    else
        message("Need at least 4 bots for a square formation.")
    end
end)

-- Circle Command: Surrounds the host in a circular formation
add({ "circle" }, function(speaker)
    local found = index()  -- Get the indices of the bots
    local numBots = #found
    if numBots < 1 then
        message("No bots available to form a circle.")
        return
    end

    local hostPlayer = players:GetPlayerByUserId(speaker.UserId)
    if not hostPlayer or not hostPlayer.Character or not hostPlayer.Character:FindFirstChild("HumanoidRootPart") then
        message("Host not found or is not in the game.")
        return
    end

    local hostPosition = hostPlayer.Character.HumanoidRootPart.Position
    local radius = 10  -- Set the radius for the circle

    for i, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            local angle = (i - 1) * (2 * math.pi / numBots)  -- Calculate angle in radians
            local offsetX = radius * math.cos(angle)  -- X offset for the circle
            local offsetZ = radius * math.sin(angle)  -- Z offset for the circle

            -- Set the bot's position around the circle
            local newPosition = hostPosition + Vector3.new(offsetX, 0, offsetZ)
            bot.Character:SetPrimaryPartCFrame(CFrame.new(newPosition)) -- Position bot
            bot.Character.HumanoidRootPart.Anchored = true -- Anchor in place
        end
    end
    message("🔴 Circle formation active.")
end)

-- Helper Command to Release Bots from Anchors
add({ "unsquare", "untriangle", "uncircle" }, function()
    local found = index()
    for _, index in ipairs(found) do
        local bot = players:GetPlayerByUserId(accounts[index])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            bot.Character.HumanoidRootPart.Anchored = false
        end
    end
    message("Bots have been released from formations.")
end)

-- Variables to control "lift" effect
local lifting = false
local liftHeight = 0.1  -- The rate of lift for the "lift" command
local liftConnections = {}

-- Box Command: Sets up the box formation around the host
add({ "box" }, function(speaker)
    local found = index()  -- Get the indices of the bots
    local hostPlayer = players:GetPlayerByUserId(speaker.UserId)
    if not hostPlayer or not hostPlayer.Character or not hostPlayer.Character:FindFirstChild("HumanoidRootPart") then
        message("Host not found or is not in the game.")
        return
    end

    -- Get host position and teleport bots in front of them
    local hostPosition = hostPlayer.Character.HumanoidRootPart.Position + Vector3.new(0, 0, -10)

    -- Place the first bot horizontally on the ground
    local firstBot = players:GetPlayerByUserId(accounts[found[1]])
    if firstBot and firstBot.Character and firstBot.Character:FindFirstChild("HumanoidRootPart") then
        firstBot.Character:SetPrimaryPartCFrame(CFrame.new(hostPosition) * CFrame.Angles(0, 0, math.rad(90)))  -- Horizontal
        firstBot.Character.HumanoidRootPart.Anchored = true  -- Fixed to ground
    end

    -- Position other bots around the first bot to form a "box"
    local boxOffsets = {
        Vector3.new(5, 0, 0),
        Vector3.new(-5, 0, 0),
        Vector3.new(0, 0, 5),
        Vector3.new(0, 0, -5)
    }
    for i = 2, #found do
        local bot = players:GetPlayerByUserId(accounts[found[i]])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            local boxPosition = hostPosition + boxOffsets[(i - 1) % 4 + 1]
            bot.Character:SetPrimaryPartCFrame(CFrame.new(boxPosition))
            bot.Character.HumanoidRootPart.Anchored = true  -- Fix to position
        end
    end

    message("📦")
end)

-- Lift Command: Gradually lifts the "box" formation upwards
add({ "lift" }, function(speaker)
    if lifting then
        message("Already lifting.")
        return
    end

    lifting = true
    -- Begin lifting all bots gradually
    for _, botId in ipairs(index()) do
        local bot = players:GetPlayerByUserId(accounts[botId])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            local connection = game:GetService("RunService").Heartbeat:Connect(function()
                if lifting then
                    local currentCFrame = bot.Character.HumanoidRootPart.CFrame
                    bot.Character:SetPrimaryPartCFrame(currentCFrame + Vector3.new(0, liftHeight, 0))
                end
            end)
            table.insert(liftConnections, connection)
        end
    end
    message("👆")
end)

-- Unlift Command: Stops the lift effect, keeping bots in place
add({ "unlift" }, function(speaker)
    lifting = false
    for _, connection in ipairs(liftConnections) do
        connection:Disconnect()
    end
    liftConnections = {}
    message("🤚")
end)

-- Unbox Command: Resets all bots to default position and cancels box, lift, and unlift commands
add({ "unbox" }, function(speaker)
    -- Reset lifting state
    lifting = false
    for _, connection in ipairs(liftConnections) do
        connection:Disconnect()
    end
    liftConnections = {}

    -- Reset all bots to unfixed positions
    for _, botId in ipairs(index()) do
        local bot = players:GetPlayerByUserId(accounts[botId])
        if bot and bot.Character and bot.Character:FindFirstChild("HumanoidRootPart") then
            bot.Character.HumanoidRootPart.Anchored = false  -- Remove anchor
        end
    end
end)

-- Fling Target Command for Bots

-- Function to get a target player by name
local GetPlayer = function(Name)
    Name = Name:lower()
    for _, x in next, players:GetPlayers() do
        if x ~= Player then
            if x.Name:lower():match("^"..Name) then
                return x;
            elseif x.DisplayName:lower():match("^"..Name) then
                return x;
            end
        end
    end
    return nil -- Return nil if no player is found
end

-- Bot Fling function (Bots will fling the target)
local FlingTargetWithBots = function(TargetPlayer, bots)
    local TCharacter = TargetPlayer.Character
    local THumanoid
    local TRootPart
    local THead

    if TCharacter and TCharacter:FindFirstChildOfClass("Humanoid") then
        THumanoid = TCharacter:FindFirstChildOfClass("Humanoid")
        TRootPart = THumanoid.RootPart
        THead = TCharacter:FindFirstChild("Head")
    else
        return -- Exit if target player is not valid
    end

    -- Fling each bot at the target
    for i, bot in ipairs(bots) do
        local BotCharacter = bot.Character
        local BotHumanoid = BotCharacter and BotCharacter:FindFirstChildOfClass("Humanoid")
        local BotRootPart = BotHumanoid and BotHumanoid.RootPart

        if BotCharacter and BotHumanoid and BotRootPart and TRootPart then
            -- Fling logic for bots
            local FPos = function(BasePart)
                BotRootPart.CFrame = CFrame.new(BasePart.Position) * CFrame.new(0, 1.5, 0)
                BotRootPart.Velocity = Vector3.new(9e8, 9e8 * 10, 9e8) -- Huge fling velocity
                BotRootPart.RotVelocity = Vector3.new(9e8, 9e8, 9e8) -- Rapid rotation
            end

            -- Make the bots repeatedly fling themselves towards the target's root part
            coroutine.wrap(function()
                local startTime = tick()
                while (tick() - startTime < 2) do -- 2 seconds of flinging
                    FPos(TRootPart) -- Fling toward the target's RootPart
                    task.wait(0.1)
                end
            end)()
        end
    end
end

-- Command to initiate bot fling
add({"fling"}, function(_, target)
    local TargetPlayer = GetPlayer(target)
    local bots = index() -- Assuming `index()` retrieves the bot instances

    if TargetPlayer then
        FlingTargetWithBots(TargetPlayer, bots)
    end
end)

    add({ "credits", "madeby", "share", "advertise", "ad" }, function(...)
        local args = {...}
        table.remove(args, 1)

        local found = index()
        for i, index in ipairs(found) do
            local bot = players:GetPlayerByUserId(accounts[index])
            if (bot) then
                message("Alt control " .. ver .. " by Pyst")
                break
            end
        end
    end)

    add({ "index", "ingame", "online" }, function()
        local count = 0
        for _,uID in ipairs(accounts) do
            if players:GetPlayerByUserId(uID) then
                count = count + 1
            end
        end
        message("Controlling " .. count .. " accounts.")
    end)

    add({ "antilag", "boostfps", "removelag" }, function()
loadstring(game:HttpGet("https://pastebin.com/raw/MGSbKm7y"))()
    message("FPS has been succesfully boosted.")
    end)

    add({ "tool", "grab" }, function()
loadstring(game:HttpGet("https://raw.githubusercontent.com/Azuaruas/thingik/refs/heads/main/thingik"))()
    end)

    add({ "hat", "hatorbit" }, function()
loadstring(game:HttpGet("https://raw.githubusercontent.com/BingusWR/Fe-Spinning-Hat-Script/refs/heads/main/Fe%20Spinning%20Hats%20Script"))()

task.wait(5)
message(";givecmd " .. controllerUser)

task.wait(1)
message(";h " .. controllerUser)

task.wait(1)
message(";speed 5")
    end)

    add({ "nameless", "extend" }, function()
loadstring(game:HttpGet("https://raw.githubusercontent.com/ltseverydayyou/Nameless-Admin/main/Source"))();

task.wait(12)
message(";admin " .. controllerUser)

task.wait(1)
message(":admin " .. controllerUser)

task.wait(1)
message("Say .ncmds or .namelesscmds to view the commands.")
    end)

    add({ "flingall" }, function()
    message("Flinging All.")
loadstring(game:HttpGet("https://pastebin.com/raw/zqyDSUWX"))()
    end)

    add({ "end", "stop" }, function()
        disallowed = true

        message("Alt control successfully closed.")
    end)

    add({ "dance", "groove" }, function(...)
        local args = {...}
        table.remove(args, 1)

        local dance = table.concat(args, " ")

        if (dance) == "1" then
            players:Chat("/e dance")
        else
            players:Chat("/e dance" .. dance)
        end
    end)

    add({ "wave", "hello" }, function()
        players:Chat("/e wave")
    end)

    add({ "cheer", "hooray" }, function()
        players:Chat("/e cheer")
    end)

    add({ "applaud", "clap" }, function()
        players:Chat("/e applaud")
    end)

    add({ "shrug", "idk", "confused" }, function()
        players:Chat("/e shrug")
    end)

    add({ "point", "pointout" }, function()
        players:Chat("/e point")
    end)

    add({ "laugh", "excite", "lol" }, function()
        players:Chat("/e laugh")
    end)

    add({ "emote", "e" }, function(...)
        local args = {...}
        table.remove(args, 1)

        local emote = table.concat(args, " ")

        players:Chat("/e " .. emote)
    end)

    add({ "reset", "kill", "oof" }, function()
        local found = index()
        for _,index in ipairs(found) do
            local bot = players:GetPlayerByUserId(accounts[index])
            if (bot) then
                bot.Character.Humanoid.Health = 0
            end
        end
    end)

    add({ "say", "chat", "m", "msg", "s" }, function(...)
        local args = {...}
        table.remove(args, 1)

        local found = index()
        for _,index in ipairs(found) do
            local bot = players:GetPlayerByUserId(accounts[index])
            if (bot) then
                message(table.concat(args, " "))
                break
            end
        end
    end)

add({ "bad", "badword", "notgood" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there are at least three bots available
    if #found >= 3 then
        local firstBot = players:GetPlayerByUserId(accounts[found[1]])
        local secondBot = players:GetPlayerByUserId(accounts[found[2]])
        local thirdBot = players:GetPlayerByUserId(accounts[found[3]])

        -- Make the first bot chat "n - k - co - f"
        if firstBot and firstBot.Character and firstBot.Character:FindFirstChild("HumanoidRootPart") then
            message("n - k - co - f") -- Only the first bot chats
        end

        -- Make the second bot chat "sh - a - sl - bo - test"
        if secondBot and secondBot.Character and secondBot.Character:FindFirstChild("HumanoidRootPart") then
            message("sh - a - sl - bo - test - d - p") -- Only the second bot chats
        end

        -- Make the third bot chat "mi - ne - ra - sp - mia - i don't give"
        if thirdBot and thirdBot.Character and thirdBot.Character:FindFirstChild("HumanoidRootPart") then
            message("mi - ne - ra - sp - mia - shut") -- Only the third bot chats
        end
    end
end)

add({ "mia" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there are at least two bots available
    if #found >= 2 then
        local firstBot = players:GetPlayerByUserId(accounts[found[1]])
        local secondBot = players:GetPlayerByUserId(accounts[found[2]])

        -- Make the first bot chat "kha"
        if firstBot and firstBot.Character and firstBot.Character:FindFirstChild("HumanoidRootPart") then
            message("kha")  -- Only the first bot chats
        end

        -- Make the second bot chat "lifa"
        if secondBot and secondBot.Character and secondBot.Character:FindFirstChild("HumanoidRootPart") then
            message("lifa")  -- Only the second bot chats
        end
    end
end)

add({ "shut" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there are at least three bots available
    if #found >= 3 then
        local firstBot = players:GetPlayerByUserId(accounts[found[1]])
        local secondBot = players:GetPlayerByUserId(accounts[found[2]])
        local thirdBot = players:GetPlayerByUserId(accounts[found[3]])

        -- Make the first bot chat "a"
        if firstBot and firstBot.Character and firstBot.Character:FindFirstChild("HumanoidRootPart") then
            message("the")  -- Only the first bot chats
        end

        -- Make the second bot chat "f"
        if secondBot and secondBot.Character and secondBot.Character:FindFirstChild("HumanoidRootPart") then
            message("f")  -- Only the second bot chats
        end

        -- Make the third bot chat "ck"
        if thirdBot and thirdBot.Character and thirdBot.Character:FindFirstChild("HumanoidRootPart") then
            message("up")  -- Only the third bot chats
        end
    end
end)

add({ "ra" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there is at least one bot available
    if #found >= 1 then
        local firstBot = players:GetPlayerByUserId(accounts[found[1]])

        -- Make the first bot chat "pe"
        if firstBot and firstBot.Character and firstBot.Character:FindFirstChild("HumanoidRootPart") then
            message("pe")  -- Only the first bot chats
        end
    end
end)

add({ "ne" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there is at least one bot available
    if #found >= 1 then
        local firstBot = players:GetPlayerByUserId(accounts[found[1]])

        -- Make the first bot chat "gg"
        if firstBot then
            message("gg")  -- Only the first bot chats
        end
    end

    -- Ensure there is a second bot available
    if #found >= 2 then
        local secondBot = players:GetPlayerByUserId(accounts[found[2]])

        -- Make the second bot chat "er"
        if secondBot then
            message("er")  -- Only the second bot chats
        end
    end
end)

add({ "mi" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there is at least one bot available
    if #found >= 1 then
        local firstBot = players:GetPlayerByUserId(accounts[found[1]])

        -- Make the first bot chat "lf"
        if firstBot then
            message("lf")  -- Only the first bot chats without username
        end
    else
        message("No bots available to execute 'mi' command.")
    end
end)

add({ "sp" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there is at least one bot available
    if #found >= 1 then
        local firstBot = players:GetPlayerByUserId(accounts[found[1]])

        -- Make the first bot chat "erm"
        if firstBot then
            message("erm")  -- Only the first bot chats without username
        end
    else
        message("No bots available to execute 'sp' command.")
    end
end)

add({ "test" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there are at least two bots available
    if #found >= 2 then
        local firstBot = players:GetPlayerByUserId(accounts[found[1]])
        local secondBot = players:GetPlayerByUserId(accounts[found[2]])

        -- Make the first bot chat "ic"
        if firstBot then
            message("ic")  -- Only the first bot chats without username
        end

        -- Make the second bot chat "les"
        if secondBot then
            message("les")  -- Only the second bot chats without username
        end
    else
        message("Not enough bots available to execute 'test' command.")
    end
end)

add({ "bo" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there is at least one bot available
    if #found >= 1 then
        local firstBot = players:GetPlayerByUserId(accounts[found[1]])

        -- Make the first bot chat "obs"
        if firstBot then
            message("obs")  -- Only the first bot chats without username
        end
    else
        message("No bots available to execute 'bo' command.")
    end
end)

add({ "sl" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there are at least three bots available
    if #found >= 3 then
        local firstBot = players:GetPlayerByUserId(accounts[found[1]])
        local secondBot = players:GetPlayerByUserId(accounts[found[2]])
        local thirdBot = players:GetPlayerByUserId(accounts[found[3]])

        -- Make each bot chat their assigned letter
        if firstBot then
            message("a")  -- Only the first bot chats "a"
        end
        if secondBot then
            message("v")  -- Only the second bot chats "v"
        end
        if thirdBot then
            message("e")  -- Only the third bot chats "e"
        end
    else
        message("Not enough bots available to execute 'sl' command.")
    end
end)

add({ "a" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there is at least one bot available for this command
    if #found >= 1 then
        local firstBot = players:GetPlayerByUserId(accounts[found[1]])

        -- Make only the first bot chat "ss"
        if firstBot then
            message("ss")  -- Only the first bot chats "ss"
        end
    else
        message("No bots available to execute 'a' command.")
    end
end)

add({ "k" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there are at least two bots available for this command
    if #found >= 2 then
        local firstBot = players:GetPlayerByUserId(accounts[found[1]])
        local secondBot = players:GetPlayerByUserId(accounts[found[2]])

        -- Make only the first and second bots chat "k"
        if firstBot then
            message("k")  -- First bot chats "k"
        end
        if secondBot then
            message("k")  -- Second bot chats "k"
        end
    else
        message("Not enough bots available to execute 'k' command.")
    end
end)

add({ "co" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there's at least one bot to execute the command
    if #found >= 1 then
        local firstBotIndex = found[1]  -- Get the first bot in the list
        local firstBot = players:GetPlayerByUserId(accounts[firstBotIndex])

        if firstBot then
            message("ck")  -- Make only the first bot say "ck"
        end
    else
        message("No bots available to execute 'co' command.")
    end
end)

add({ "sh" }, function()
    local found = index()  -- Locate active bots using the `index` function

    -- Ensure there's at least one bot to execute the command
    if #found >= 1 then
        local firstBotIndex = found[1]  -- Get the first bot in the list
        local firstBot = players:GetPlayerByUserId(accounts[firstBotIndex])

        if firstBot then
            message("it")  -- Make only the first bot say "it"
        end
    else
        message("No bots available to execute 'sh' command.")
    end
end)

add({ "d" }, function()
    local found = index()  -- Locate active bots using the `index` function
    local letters = { "i", "sc", "ord" }

    -- Ensure there are enough bots for each letter
    if #found >= #letters then
        -- For each letter, make the corresponding bot say it
        for i, letter in ipairs(letters) do
            local botIndex = found[i]
            local bot = players:GetPlayerByUserId(accounts[botIndex])
            if bot then
                message(letter)  -- Make only the bot output the letter without the username
            end
        end
    else
        message("Not enough bots to execute 'n' command.")
    end
end)

add({ "f" }, function()
    local found = index()  -- Locate active bots using the `index` function
    local letters = { "u", "c", "k" }

    -- Ensure there are enough bots for each letter
    if #found >= #letters then
        -- For each letter, make the corresponding bot say it
        for i, letter in ipairs(letters) do
            local botIndex = found[i]
            local bot = players:GetPlayerByUserId(accounts[botIndex])
            if bot then
                message(letter)  -- Each bot outputs only the letter, without its username
            end
        end
    else
        message("Not enough bots to execute 'f' command.")
    end
end)

add({ "p" }, function()
    local found = index()  -- Locate active bots using the `index` function
    local letters = { "o", "r", "n" }

    -- Ensure there are enough bots for each letter
    if #found >= #letters then
        -- For each letter, make the corresponding bot say it
        for i, letter in ipairs(letters) do
            local botIndex = found[i]
            local bot = players:GetPlayerByUserId(accounts[botIndex])
            if bot then
                message(letter)  -- Each bot outputs only the letter, without its username
            end
        end
    else
        message("Not enough bots to execute 'p' command.")
    end
end)

    add({ "undance", "jump", "stopdance", "j" }, function()
        localPlayer.Character.Humanoid.Jump = true
    end)

    local response = function(input: string)
        if not (disallowed) then
            dur = tick()

            if (string.sub(input, 1, #prefix)) == prefix then
                local command = string.sub(input, #prefix + 1)
                local args = { }

                for arg in string.gmatch(command, "%S+") do
                    table.insert(args, arg)
                end

                local functions = commands[args[1]]
                if (functions) then
                    functions.functions(unpack(args))
                else
                    message('Command "' .. command .. '" not found.')
                end
            end
        end
    end

    if (version()) == "New" then
        textChat.MessageReceived:Connect(function(textChatMessage)
            local author = tostring(textChatMessage.TextSource)

            if (author) == model.Name then
                response(textChatMessage.Text)
            end
        end)
    else
        model.Chatted:Connect(function(input: string)
            response(input)
        end)
    end

    message("Alt control " .. ver .. " loaded in " .. string.format("%.2f", tick() - dur) .. " seconds, say .cmds to view the commands.")
else
    message("Main Account not found, cannot use Alt control.")
end