Need some direction with bee swarm style mining script?

Hello,

Very fun question. Let's unpack it to make sure we're on the same page:

After going and playing "Bee Swarm Simulator" for about a minute, I seem to notice something. It appears as if each Bee chooses a random part that is within a certain radius to the player, farms the part, and then chooses another part within a certain radius of the player. This means that we have to construct an algorithm to:

1. Figure out which flower field the player is on.

2. Search through each flower part in the field and measure the distance between a given flower and the player.

3. Choose a random flower part that is within the distance given.

Pretty straightforward.

To figure out which field the player is located on, we could use various methods. The method I am going to use will be checking if the player's location is within a certain area. To do this I create minimum and maximum x and z values to check against the player's position. We encapsulate this code in a function so that we can use it later.

Implementation of said function:

local minx = 0
local maxx = 100
local minz = 0
local maxz = 100

local function infield(player) --input with player object
	local char = player.Character or workspace:WaitForChild(player.Name)
	local plrpos = char.PrimaryPart.Position
	local plrposx = plrpos.X
	local plrposz = plrpos.Z

	if (plrposx >= minx) and (plrposx <= maxx) and (plrposz >= minz) and (plrposz <= maxz) then
		return true, workspace.Field1
	else
		return false, nil
	end
end)

I will note that this function is very simple and only accounts for one field, but in reality, you're probably going to be using touch interests to be figuring out the position/field anyway. If you really do want to use a function like this though, we could create a 2d array to store the info of each field.

An example of said system is shown below. We assume that you have a folder in the workspace called "Fields" that contains invisible, anchored, and non-collidible parts to represent the boundaries of each field. We also assume that the parts are named the same as each real field that is parented to the workspace. Using these parts, we can create many arrays of many maximum and minimum x and z values.

local allfields = {}

for i,v in pairs(workspace.Fields:GetChildren()) do
	local ms = v.Size
	local mp = v.Position

	local xl = mp.X - ms.X/2
	local xm = mp.X + ms.X/2

	local zl = mp.Z - ms.Z/2
	local zm = mp.Z + ms.Z/2

	table.Insert(allfields,{v.Name,xm,xl,zm,zl})	--insert min/max info into big table
end

local function infield(player) --input with player object
	local char = player.Character or workspace:WaitForChild(player.Name)
	local plrpos = char.PrimaryPart.Position
	local plrposx = plrpos.X
	local plrposz = plrpos.Z

	for i,v in pairs(allfields) do
		if (plrposx >= v[2]) and (plrposx <= v[3]) and (plrposz >= v[4]) and (plrposz <= v[5]) then
		return true, workspace[v[1]]
	end

	return false, nil
end)

Alright, now that we've gone over figuring out the player's field, we can go on searching through all the flower objects in the field. To do this, we'll create a function that searches through the field and checks the distance between the player and the flower part. Luckily for us, Roblox already has a function that can check the distance between two points called Magnitude. This means that we just have to loop, use the function, and then add it to a table if it's within our threshold.

local distance = 10

local function searchfield(player,field)
	local char = player.Character or workspace:WaitForChild(player.Name)
	local plrpos = char.PrimaryPart.Position

	local accepted = {}

	for i,v in pairs(field:GetChildren()) do
		if (plrpos - v.Position).Magnitude <= distance then
			table.Insert(accepted,v)
		end
	end

	return accepted
end)

Now, we simply choose a random value within our table. To do this cleanly, I'm going to create yet another function that incorporates our previous functions

local function pickflower(player)
	local in, field = infield(player)
	if in == false then
		return false
	end
	
	local flowers = searchfield(player,field)
	
	if #flowers == 0 then
		return false
	end

	return flowers[math.random(1,#flowers)]
end)

Let's put all our code together:

local allfields = {}

for i,v in pairs(workspace.Fields:GetChildren()) do
	local ms = v.Size
	local mp = v.Position

	local xl = mp.X - ms.X/2
	local xm = mp.X + ms.X/2

	local zl = mp.Z - ms.Z/2
	local zm = mp.Z + ms.Z/2

	table.Insert(allfields,{v.Name,xm,xl,zm,zl})
end

local function infield(player)
	local char = player.Character or workspace:WaitForChild(player.Name)
	local plrpos = char.PrimaryPart.Position
	local plrposx = plrpos.X
	local plrposz = plrpos.Z

	for i,v in pairs(allfields) do
		if (plrposx >= v[2]) and (plrposx <= v[3]) and (plrposz >= v[4]) and (plrposz <= v[5]) then
		return true, workspace[v[1]]
	end

	return false, nil
end)

local distance = 10

local function searchfield(player,field)
	local char = player.Character or workspace:WaitForChild(player.Name)
	local plrpos = char.PrimaryPart.Position

	local accepted = {}

	for i,v in pairs(field:GetChildren()) do
		if (plrpos - v.Position).Magnitude <= distance then
			table.Insert(accepted,v)
		end
	end

	return accepted
end)

local function pickflower(player)
	local inA, field = infield(player)
	if inA == false then
		return false
	end
	
	local flowers = searchfield(player,field)
	
	if #flowers == 0 then
		return false
	end

	return flowers[math.random(1,#flowers)]
end)

Why is this any better?

With a function-oriented system, we've made it easier to change our code, easier to scale up our game/functions, easier for others to read your code, AND we've created a robust system that is able to properly manage which flowers to pick, instead of just firing Rays all around.

Implementation

Ok, we can pick a flower! Now what? Let's implement your code:

We can create a variable named 'Bees' that will dictate how many bees we have access to, we then take this number and use it to dictate how many parts should be moved down. Another thing we can add is a loop that tells the bees when to mine blocks.

An implementation of this is seen below:

local bees = 5

while true do
	for i,v in pairs(game:GetService("Players"):GetChildren()) do
		local pick = pickflower(v)

		if pick ~= false then
			local maxbees = bees

			if maxbees > #pick then
				maxbees = #pick
			end

			for bee = 1, maxbees do
				local num = math.random(1,#pick)
				local picked = pick[num]
				table.remove[pick,num]

				--do whatever you want with picked
			end
		end
	end

	wait(1)
end

Practice Exercises

• Implement the code so that many different people can farm

• Make the number of bees differ from person to person

• Make the number of bees save when you rejoin

Resources

Below is documentation discussing everything I have used and explained to you in this post:

Functions

Basic Loops

I'V Pairs

Magnitude

Conclusion

I hope I was able to help set you in a positive direction!

Cheers,

Chase