Roblox bedwars /beehive ability / bedwars script

local radius = 20 -- radius to attake bees
local itemNeeded = ItemType.HEADHUNT_SKULL -- item needed
local amountNeeded = 5 -- amount needed of item
local maxBeehivePlacement = 5 -- max beehives a player can place
local maxBees = 10 -- max bees that can be in radius  local despawnTime = 30 -- time beehive can be alive
local playersBeehive = {}
local currentPlayerBeehives = {}

AbilityService.createAbility("beehive_ability", "KitSecondary", {
    maxProgress = 10,
    progressPerUse = 5,
    iconImage = "rbxassetid://135845664733177"
})

for _, player in pairs(PlayerService.getPlayers()) do
    local abilities = AbilityService.getAbilities(player) or {}
    local hasAbility = false
    for _, a in pairs(abilities) do
        if a == "beehive_ability" then
            hasAbility = true
            break
        end
    end
    if not hasAbility then
        AbilityService.enableAbility(player, "beehive_ability")
        MessageService.sendInfo(player, "Enabled ability: beehive_ability")
    else
        MessageService.sendError(player, "You already have ability: beehive_ability")
    end
end

Events.EntitySpawn(function(event)
    local player = event.entity:getPlayer()
    if not player then return end

    local abilities = AbilityService.getAbilities(player) or {}
    local hasAbility = false
    for _, a in pairs(abilities) do
        if a == "beehive_ability" then
            hasAbility = true
            break
        end
    end

    if not hasAbility then
        AbilityService.enableAbility(player, "beehive_ability")
        MessageService.sendInfo(player, "Enabled ability: beehive_ability")
    else
        MessageService.sendError(player, "You already have ability: beehive_ability")
    end
end)

local function createBeehiveAt(basePos, player)
    local shake = false
    local radius = 20
    local baseParts = {}
    local beesCount = 0
    local activeBees = {}
    local findRadius = radius + 1.5
    local despawnTime = 30
    local timerDefault = despawnTime

    if not playersBeehive[player] then
        playersBeehive[player] = {}
    end

    if #playersBeehive[player] >= maxBeehivePlacement then
        MessageService.sendError(player, "You can only have " .. maxBeehivePlacement .. " beehive at a time!")
        return
    end

    local blockBelowPos = basePos - Vector3.new(0, 3, 0)
    for _, pos in ipairs(playersBeehive[player]) do
        if (pos - blockBelowPos).Magnitude < 1 then
            MessageService.sendError(player, "You can't place beehive on top of each other")
            return
        end
    end

    table.insert(playersBeehive[player], blockBelowPos)
    currentPlayerBeehives[blockBelowPos] = {index = #playersBeehive[player]}

    local blockBelow = BlockService.getBlockAt(blockBelowPos)
    local originalBlockType = nil
    if blockBelow then
        originalBlockType = blockBelow.blockType
        BlockService.destroyBlock(blockBelowPos)
        BlockService.placeBlock(ItemType.GLOWSTONE, blockBelowPos)
    end

    local model = ModelService.createItemModel(ItemType.BEEHIVE_GRENADE, basePos + Vector3.new(0, 2.8, -1.2))
    model:setScale(2)
    model:setAnchored(true)
    model:setCollidable(false)

    local part1 = PartService.createPart(ItemType.CLAY_LIGHT_BROWN, basePos + Vector3.new(0, 1.7, 1.5))
    part1:setSize(Vector3.new(0.5, 6.5, 0.5))
    part1:setAnchored(true)
    part1:setCollidable(false)

    local part2 = PartService.createPart(ItemType.CLAY_LIGHT_BROWN, basePos + Vector3.new(0, 4.7, -0.1))
    part2:setSize(Vector3.new(0.5, 0.5, 2.8))
    part2:setAnchored(true)
    part2:setCollidable(false)

    MessageService.sendInfo(player, "Beehive (" .. currentPlayerBeehives[blockBelowPos].index .. ") will despawn in " .. timerDefault .. " seconds")

    local function getNearbyEnemies(center, radiusToUse)
        local allEntities, seen = {}, {}
        for y = -300, 300, 20 do
            local checkCenter = Vector3.new(center.X, center.Y + y, center.Z)
            local nearby = EntityService.getNearbyEntities(checkCenter, radiusToUse)
            if nearby then
                for _, e in ipairs(nearby) do
                    if not seen[e] then
                        local ePlayer = e:getPlayer()
                        local pTeam = TeamService.getTeam(player)
                        local eTeam = ePlayer and TeamService.getTeam(ePlayer) or nil
                        if eTeam ~= pTeam then
                            seen[e] = true
                            table.insert(allEntities, e)
                        end
                    end
                end
            end
        end
        return (#allEntities > 0) and allEntities or nil
    end

    task.spawn(function()
        local pivot = model:getCFrame()
        while despawnTime > 0 do
            local nearbyEntities = getNearbyEnemies(basePos, findRadius)
            shake = nearbyEntities and #nearbyEntities > 0
            if shake then
                local angle = math.sin(tick() * 40) * math.rad(2)
                model:setCFrame(pivot * CFrame.Angles(0, 0, angle))
            else
                model:setCFrame(pivot)
            end
            task.wait(0.02)
        end
    end)

    local function makeParts(center, radius)
        local count, size, parts = 8 + (radius * 2), Vector3.new(1, 0.2, 0.3), {}
        for i = 1, count do
            local angle = (i / count) * math.pi * 2
            local pos = center + Vector3.new(math.cos(angle) * (radius + 1.3), 7, math.sin(angle) * (radius + 1.3))
            local p = PartService.createPart(ItemType.WOOL_WHITE, pos)
            p:setSize(size)
            p:setAnchored(true)
            p:setCollidable(false)
            p.initialY = pos.Y
            parts[i] = p
        end
        return parts
    end

    local function updateParts(parts, center, radius)
        local target = center + Vector3.new(0, -1.5, 0)
        for i = 1, #parts do
            local angle = (i / #parts) * math.pi * 2
            local checkX = center.X + math.cos(angle) * (radius + 1.3)
            local checkZ = center.Z + math.sin(angle) * (radius + 1.3)
            local y = parts[i].initialY
            local minY = center.Y - 60
            while y > minY and not BlockService.getBlockAt(Vector3.new(checkX, y, checkZ)) do
                y = y - 1
            end
            local final = Vector3.new(checkX, y + 0.5, checkZ)
            parts[i]:setPosition(final)
            parts[i]:setCFrame(CFrame.new(final, target))
        end
    end

    baseParts = makeParts(basePos, radius)
    task.spawn(function()
        while despawnTime > 0 do
            updateParts(baseParts, basePos, radius)
            task.wait(0.1)
        end
    end)

    local timerLabel = UIService.createTextLabel("⏱️ " .. timerDefault, basePos + Vector3.new(0, 7, 0))
    timerLabel:setBackgroundColor(Color3.fromRGB(0, 0, 0))
    timerLabel:setBackgroundTransparency(0.2)
    timerLabel:setTextColor(Color3.fromRGB(255, 255, 255))
    timerLabel:setSize(UDim2.fromScale(12, 3))
    timerLabel:setFont(Font.Arial)

    task.spawn(function()
        while despawnTime > 0 do
            timerLabel:setText("⏱️ " .. math.ceil(despawnTime))
            despawnTime = despawnTime - 1
            task.wait(1)
        end
    end)

    task.spawn(function()
        while despawnTime > 0 do
            if beesCount < maxBees then
                local nearbyEntities = getNearbyEnemies(basePos, findRadius)
                if nearbyEntities and #nearbyEntities > 0 then
                    local totalEntities = #nearbyEntities
                    local beesPerEntity = math.floor(maxBees / totalEntities)
                    local remainingBees = maxBees % totalEntities
                    local targetAssignments = {}
                    for i, entityTarget in ipairs(nearbyEntities) do
                        local count = beesPerEntity
                        if remainingBees > 0 then
                            count = count + 1
                            remainingBees = remainingBees - 1
                        end
                        for j = 1, count do
                            table.insert(targetAssignments, entityTarget)
                        end
                    end
                    for _, targetEntity in ipairs(targetAssignments) do
                        local bee = ModelService.createModel(ModelType.BEE, model:getPosition())
                        bee:setScale(1)
                        bee:setAnchored(true)
                        bee:setCollidable(false)
                        table.insert(activeBees, bee)
                        beesCount = beesCount + 1
                        local offset = Vector3.new(0, 0, math.random(-23, 23) / 10)
                        task.spawn(function()
                            local speed = 0.7
                            while bee and despawnTime > 0 do
                                if not targetEntity or not targetEntity:isAlive() or (targetEntity:getPosition() - basePos).Magnitude > findRadius then
                                    local nearby = getNearbyEnemies(basePos, findRadius)
                                    if nearby and #nearby > 0 then
                                        targetEntity = nearby[math.random(1, #nearby)]
                                        offset = Vector3.new(0, 0, math.random(-23, 23) / 10)
                                    else
                                        targetEntity = nil
                                    end
                                end
                                local targetPos = targetEntity and targetEntity:isAlive() and (targetEntity:getPosition() + offset) or model:getPosition()
                                local currentPos = bee:getPosition()
                                local direction = targetPos - currentPos
                                if direction.Magnitude > 0.05 then
                                    direction = direction.Unit
                                    local newPos = currentPos + direction * speed
                                    bee:setPosition(newPos)
                                    bee:setCFrame(CFrame.new(newPos, targetPos))
                                else
                                    if not targetEntity and (currentPos - model:getPosition()).Magnitude <= 2 then
                                        bee:destroy()
                                        table.remove(activeBees, table.find(activeBees, bee))
                                        beesCount = beesCount - 1
                                        return
                                    end
                                end
                                local nearby = EntityService.getNearbyEntities(bee:getPosition(), 3)
                                if nearby then
                                    for _, e in ipairs(nearby) do
                                        if e:isAlive() then
                                            local ePlayer = e:getPlayer()
                                            local pTeam = TeamService.getTeam(player)
                                            local eTeam = ePlayer and TeamService.getTeam(ePlayer) or nil
                                            if eTeam ~= pTeam then
                                                CombatService.damage(e, 10)
                                                bee:destroy()
                                                table.remove(activeBees, table.find(activeBees, bee))
                                                beesCount = beesCount - 1
                                                return
                                            end
                                        end
                                    end
                                end
                                task.wait(0.05)
                            end
                        end)
                        task.wait(0.1)
                    end
                else
                    task.wait(0.5)
                end
            else
                task.wait(0.5)
            end
        end
    end)

    task.spawn(function()
        task.wait(timerDefault)
        if BlockService.getBlockAt(blockBelowPos) then
            BlockService.destroyBlock(blockBelowPos)
            if originalBlockType then
                BlockService.placeBlock(originalBlockType, blockBelowPos)
            end
        end
        model:destroy()
        part1:destroy()
        part2:destroy()
        for _, p in ipairs(baseParts) do p:destroy() end
        for _, bee in ipairs(activeBees) do bee:destroy() end
        timerLabel:destroy()
        MessageService.sendInfo(player, "Beehive (" .. currentPlayerBeehives[blockBelowPos].index .. ") time has run out")
        table.remove(playersBeehive[player], table.find(playersBeehive[player], blockBelowPos))
        currentPlayerBeehives[blockBelowPos] = nil
    end)

    return {model = model, parts = baseParts, activeBees = activeBees}
end


Events.UseAbility(function(event)
    if event.abilityName ~= "beehive_ability" then return end
    local player = event.entity:getPlayer()
    if not player then return end

    if InventoryService.getAmount(player, itemNeeded) < amountNeeded then
        MessageService.sendError(player, "You need "..amountNeeded.." "..tostring(itemNeeded).." to use this ability!")
        return
    end

    InventoryService.removeItemAmount(player, itemNeeded, amountNeeded)

    if not playersBeehive[player] then
        playersBeehive[player] = {}
    end

    if #playersBeehive[player] >= maxBeehivePlacement then
        MessageService.sendError(player, "You have already placed the maximum number of beehives!")
        return
    end

    local entity = player:getEntity()
    if entity and entity:getPosition() then
        local pos = entity:getPosition()
        local snappedBasePos = Vector3.new(
            math.floor(pos.X + 0.5),
            math.floor(pos.Y - 2 + 0.5),
            math.floor(pos.Z + 0.5)
        )
        createBeehiveAt(snappedBasePos, player)
    end
end)

Events.EntityDeath(function(event)
    local player = event.entity:getPlayer()
    if player and playersBeehive[player] and #playersBeehive[player] > 0 then
        for _, blockPos in ipairs(playersBeehive[player]) do
            local hiveData = currentPlayerBeehives[blockPos]
            if hiveData then
                if hiveData.model then hiveData.model:destroy() end
                for _, part in ipairs(hiveData.parts or {}) do part:destroy() end
                for _, bee in ipairs(hiveData.activeBees or {}) do bee:destroy() end
                currentPlayerBeehives[blockPos] = nil
            end
        end
        playersBeehive[player] = {}
        MessageService.sendError(player, "All beehives have been destroyed on death")
    end
end)