View difference between Paste ID: LfQiYjp4 and gXa8k1tJ

 -- setup is turtle facing apiary, with a (large, maybe dimensional storage) chest beneath the turtle
 -- another chest on top is used for produce and extra drones
 
 -- gXa8k1tJ
 -- fKC8kx5b
 -- H0CppXue
 -- QTRQHPhM
 -- RwTbaqpP
 
 local apiary = peripheral.wrap("front")
 local chest = peripheral.wrap("bottom")
 local maxDrones = 6
 local minDrones = 3
 
 bees = {}
 stacks = {}
 shutdownMsg = nil
 
 function addParent(parent, offspring)
     if not bees[parent] then
     bees[parent] = {
         --name = parent,
         score = 0,
         mutateFrom = {}
     }
     end
 end
 
 function addOffspring(offspring, parentss)
     if bees[offspring] then
     for i, parents in ipairs(parentss) do
         table.insert(bees[offspring].mutateFrom, parents)
     end
     else
     bees[offspring] = {
         score = 0,
         mutateFrom = parentss
     }
     end
     for i, parents in ipairs(parentss) do
     for i, parent in ipairs(parents) do
         addParent(parent, offspring)
     end
     end
 end
 
 
 
 
 -- produce combinations from 1 or 2 lists
 function choose(list, list2)
     local newList = {}
     if list2 then
     for i = 1, #list2 do
         for j = 1, #list do
         if list[j] ~= list[i] then
             table.insert(newList, {list[j], list2[i]})
         end
         end
     end
     else
     for i = 1, #list do
         for j = i, #list do
         if list[i] ~= list[j] then
             table.insert(newList, {list[i], list[j]})
         end
         end
     end
     end
     return newList
 end
 
 
 --bee list from Master Apiarist Database v3.1
 --Forestry v2.3.0.7 (683)
 --Extra Bees v1.8-dev2
 --Magic Bees v2.1.7 (build 78)
 
 addOffspring("Common", choose({"Forest", "Meadows", "Modest", "Wintry", "Tropical", "Marshy", "Water", "Rocky", "Mystical", "Sorcerous", "Unusual", "Attuned"}))
 addOffspring("Cultivated", choose({"Common"}, {"Forest", "Meadows", "Modest", "Wintry", "Tropical", "Marshy", "Water", "Rocky", "Mystical", "Sorcerous", "Unusual", "Attuned"}))
 
 addOffspring("Noble", {{"Common", "Cultivated"}})
 addOffspring("Majestic", {{"Noble", "Cultivated"}})
 addOffspring("Imperial", {{"Noble", "Majestic"}})
 addOffspring("Diligent", {{"Common", "Cultivated"}})
 addOffspring("Unweary", {{"Diligent", "Cultivated"}})
 addOffspring("Industrious", {{"Diligent", "Unweary"}})
 addOffspring("Heroic", {{"Steadfast", "Valiant"}})
 addOffspring("Sinister", choose({"Cultivated"}, {"Modest", "Tropical"}))
 addOffspring("Fiendish", choose({"Sinister"}, {"Cultivated", "Modest", "Tropical"}))
 addOffspring("Frugal", choose({"Modest"}, {"Sinister", "Fiendish"}))
 addOffspring("Demonic", {{"Sinister", "Fiendish"}})
 addOffspring("Austere", {{"Modest", "Frugal"}})
 addOffspring("Exotic", {{"Austere", "Tropical"}})
 addOffspring("Edenic", {{"Exotic", "Tropical"}})
 addOffspring("Spectral", {{"Hermitic", "Ender"}})
 addOffspring("Phantasmal", {{"Spectral", "Ender"}})
 addOffspring("Icy", {{"Industrious", "Wintry"}})
 addOffspring("Glacial", {{"Icy", "Wintry"}})
 addOffspring("Vindictive", {{"Monastic", "Demonic"}})
 addOffspring("Vengeful", choose({"Vindictive"}, {"Demonic", "Monastic"}))
 addOffspring("Avenging", {{"Vengeful", "Vindictive"}})
 addOffspring("Leporine", {{"Meadows", "Forest"}})
 addOffspring("Merry", {{"Wintry", "Forest"}})
 addOffspring("Tipsy", {{"Wintry", "Meadows"}})
 addOffspring("Tricky", {{"Sinister", "Common"}})
 addOffspring("Rural", {{"Meadows", "Diligent"}})
 addOffspring("Secluded", {{"Monastic", "Austere"}})
 addOffspring("Hermitic", {{"Monastic", "Secluded"}})
 addOffspring("Arid", {{"Meadows", "Modest"}})
 addOffspring("Barren", {{"Arid", "Common"}})
 addOffspring("Desolate", {{"Arid", "Barren"}})
 addOffspring("Decaying", {{"Desolate", "Modest"}})
 addOffspring("Skeletal", {{"Desolate", "Frugal"}})
 addOffspring("Creepy", {{"Desolate", "Austere"}})
 addOffspring("Decomposing", {{"Gnawing", "Common"}})
 addOffspring("Tolerant", {{"Rocky", "Diligent"}})
 addOffspring("Robust", {{"Rocky", "Tolerant"}})
 addOffspring("Resilient", {{"Imperial", "Robust"}})
 addOffspring("Corroded", {{"Resilient", "Forest"}})
 addOffspring("Tarnished", {{"Resilient", "Marshy"}})
 addOffspring("Rusty", {{"Resilient", "Meadows"}})
 addOffspring("Leaden", {{"Resilient", "Unweary"}})
 addOffspring("Galvanized", {{"Tarnished", "Cultivated"}})
 addOffspring("Impregnable", {{"Resilient", "Noble"}})
 addOffspring("Invincible", {{"Resilient", "Ender"}})
 addOffspring("Glittering", {{"Corroded", "Imperial"}})
 addOffspring("Shining", {{"Rusty", "Imperial"}})
 addOffspring("Valuable", {{"Glittering", "Shining"}})
 addOffspring("Lapis", {{"Resilient", "Water"}})
 addOffspring("Emerald", {{"Lapis", "Noble"}})
 addOffspring("Ruby", {{"Emerald", "Austere"}})
 addOffspring("Sapphire", {{"Emerald", "Ocean"}})
 addOffspring("Diamond", {{"Lapis", "Imperial"}})
 addOffspring("Unstable", {{"Austere", "Rocky"}})
 addOffspring("Nuclear", {{"Unstable", "Rusty"}})
 addOffspring("Radioactive", {{"Nuclear", "Glittering"}})
 addOffspring("Ancient", {{"Noble", "Diligent"}})
 addOffspring("Primeval", {{"Ancient", "Noble"}})
 addOffspring("Prehistoric", {{"Primeval", "Majestic"}})
 addOffspring("Relic", {{"Prehistoric", "Imperial"}})
 addOffspring("Fossilised", {{"Primeval", "Growing"}})
 addOffspring("Resinous", {{"Primeval", "Fungal"}})
 addOffspring("Oily", {{"Primeval", "Ocean"}})
 addOffspring("Distilled", {{"Oily", "Industrious"}})
 addOffspring("Refined", {{"Oily", "Distilled"}})
 addOffspring("Elastic", {{"Refined", "Resinous"}})
 addOffspring("River", {{"Water", "Common"}})
 addOffspring("Ocean", {{"Water", "Diligent"}})
 addOffspring("Stained", {{"Ebony", "Ocean"}})
 addOffspring("Growing", {{"Diligent", "Forest"}})
 addOffspring("Thriving", {{"Growing", "Rural"}})
 addOffspring("Blooming", {{"Thriving", "Growing"}})
 addOffspring("Sweetened", {{"Valiant", "Diligent"}})
 addOffspring("Sugary", {{"Sweetened", "Diligent"}})
 addOffspring("Ripening", {{"Sugary", "Forest"}})
 addOffspring("Fruity", {{"Ripening", "Rural"}})
 addOffspring("Farmed", {{"Cultivated", "Rural"}})
 addOffspring("Bovine", {{"Rural", "Water"}})
 addOffspring("Caffeinated", {{"Tropical", "Rural"}})
 addOffspring("Minty", {{"Tropical", "Farmed"}})
 addOffspring("Damp", {{"Common", "Marshy"}})
 addOffspring("Boggy", {{"Damp", "Marshy"}})
 addOffspring("Fungal", {{"Boggy", "Damp"}})
 addOffspring("Furious", {{"Embittered", "Sinister"}})
 addOffspring("Volcanic", {{"Embittered", "Furious"}})
 addOffspring("Malicious", {{"Sinister", "Tropical"}})
 addOffspring("Infectious", {{"Malicious", "Tropical"}})
 addOffspring("Virulent", {{"Malicious", "Infectious"}})
 addOffspring("Viscous", {{"Water", "Exotic"}})
 addOffspring("Glutinous", {{"Viscous", "Exotic"}})
 addOffspring("Sticky", {{"Viscous", "Glutinous"}})
 addOffspring("Corrosive", {{"Virulent", "Sticky"}})
 addOffspring("Caustic", {{"Corrosive", "Fiendish"}})
 addOffspring("Acidic", {{"Corrosive", "Caustic"}})
 addOffspring("Excited", {{"Cultivated", "Valiant"}})
 addOffspring("Energetic", {{"Excited", "Valiant"}})
 addOffspring("Frigid", {{"Wintry", "Diligent"}})
 addOffspring("Absolute", {{"Ocean", "Frigid"}})
 addOffspring("Shadowed", {{"Tolerant", "Sinister"}})
 addOffspring("Darkened", {{"Shadowed", "Embittered"}})
 addOffspring("Abyssal", {{"Shadowed", "Darkened"}})
 addOffspring("Maroon", {{"Forest", "Valiant"}})
 addOffspring("Saffron", {{"Meadows", "Valiant"}})
 addOffspring("Prussian", {{"Water", "Valiant"}})
 addOffspring("Natural", {{"Tropical", "Valiant"}})
 addOffspring("Ebony", {{"Rocky", "Valiant"}})
 addOffspring("Bleached", {{"Wintry", "Valiant"}})
 addOffspring("Sepia", {{"Marshy", "Valiant"}})
 addOffspring("Amber", {{"Maroon", "Saffron"}})
 addOffspring("Turquoise", {{"Natural", "Prussian"}})
 addOffspring("Indigo", {{"Maroon", "Prussian"}})
 addOffspring("Slate", {{"Ebony", "Bleached"}})
 addOffspring("Azure", {{"Prussian", "Bleached"}})
 addOffspring("Lavender", {{"Maroon", "Bleached"}})
 addOffspring("Lime", {{"Natural", "Bleached"}})
 addOffspring("Fuchsia", {{"Indigo", "Lavender"}})
 addOffspring("Ashen", {{"Slate", "Bleached"}})
 addOffspring("Celebratory", {{"Austere", "Excited"}})
 addOffspring("Jaded", {{"Ender", "Relic"}})
 addOffspring("Glowering", {{"Furious", "Excited"}})
 addOffspring("Hazardous", {{"Austere", "Desolate"}})
 addOffspring("Lustered", {{"Resilient", "Unweary"}})
 addOffspring("Abnormal", {{"Secluded", "Ender"}})
 addOffspring("Spatial", {{"Abnormal", "Hermitic"}})
 addOffspring("Quantum", {{"Spatial", "Spectral"}})
 addOffspring("Eldritch", choose({"Cultivated"}, {"Mystical", "Sorcerous", "Unusual", "Attuned"}))
 addOffspring("Esoteric", {{"Cultivated", "Eldritch"}})
 addOffspring("Mysterious", {{"Eldritch", "Esoteric"}})
 addOffspring("Arcane", {{"Esoteric", "Mysterious"}})
 addOffspring("Charmed", {{"Cultivated", "Eldritch"}})
 addOffspring("Enchanted", {{"Eldritch", "Charmed"}})
 addOffspring("Supernatural", {{"Charmed", "Enchanted"}})
 addOffspring("Ethereal", {{"Arcane", "Supernatural"}})
 addOffspring("Watery", {{"Supernatural", "Ethereal"}})
 addOffspring("Earthen", {{"Supernatural", "Ethereal"}})
 addOffspring("Firey", {{"Supernatural", "Ethereal"}})
 addOffspring("Windy", {{"Supernatural", "Ethereal"}})
 addOffspring("Pupil", {{"Monastic", "Arcane"}})
 addOffspring("Scholarly", {{"Arcane", "Pupil"}})
 addOffspring("Savant", {{"Pupil", "Scholarly"}})
 addOffspring("Aware", {{"Ethereal", "Attuned"}})
 addOffspring("Spirit", choose({"Aware"}, {"MystEtherealical", "Attuned"}))
 addOffspring("Soul", {{"Aware", "Spirit"}})
 addOffspring("Skulking", {{"Modest", "Eldritch"}})
 addOffspring("Ghastly", {{"Skulking", "Ethereal"}})
 addOffspring("Spidery", {{"Tropical", "Skulking"}})
 addOffspring("Smouldering", {{"Skulking", "Hateful"}})
 addOffspring("Timely", {{"Imperial", "Ethereal"}})
 addOffspring("Lordly", {{"Imperial", "Timely"}})
 addOffspring("Doctoral", {{"Timely", "Lordly"}})
 addOffspring("Infernal", {{"Infernal", "ves"}})
 addOffspring("Hateful", {{"Infernal", "Eldritch"}})
 addOffspring("Spiteful", {{"Infernal", "Hateful"}})
 addOffspring("Withering", {{"Demonic", "Spiteful"}})
 addOffspring("Oblivion", {{"Oblivion", "ves"}})
 addOffspring("Nameless", {{"Ethereal", "Oblivion"}})
 addOffspring("Abandoned", {{"Oblivion", "Nameless"}})
 addOffspring("Forlorn", {{"Nameless", "Abandoned"}})
 addOffspring("Draconic", {{"Imperial", "Abandoned"}})
 addOffspring("Ferrous", {{"Common", "Industrious"}})
 addOffspring("Auric", {{"Minium", "Plumbum"}})
 addOffspring("Cuprum", {{"Industrious", "Meadows"}})
 addOffspring("Stannum", {{"Industrious", "Forest"}})
 addOffspring("Argentum", {{"Imperial", "Modest"}})
 addOffspring("Plumbum", {{"Stannum", "Common"}})
 addOffspring("Aluminum", {{"Industrious", "Cultivated"}})
 addOffspring("Ardite", {{"Industrious", "Infernal"}})
 addOffspring("Cobalt", {{"Imperial", "Infernal"}})
 addOffspring("Manyullyn", {{"Ardite", "Cobalt"}})
 addOffspring("Diamandi", {{"Austere", "Auric"}})
 addOffspring("Esmeraldi", {{"Austere", "Argentum"}})
 addOffspring("Apatine", {{"Rural", "Cuprum"}})
 addOffspring("Mutable", {{"Unusual", "Eldritch"}})
 addOffspring("Transmuting", {{"Unusual", "Mutable"}})
 addOffspring("Crumbling", {{"Unusual", "Mutable"}})
 addOffspring("Invisible", {{"Mystical", "Mutable"}})
 addOffspring("Aer", {{"Windy", "Windy"}})
 addOffspring("Ignis", {{"Firey", "Firey"}})
 addOffspring("Aqua", {{"Watery", "Watery"}})
 addOffspring("Solum", {{"Earthen", "Earthen"}})
 addOffspring("Ordered", {{"Ethereal", "Arcane"}})
 addOffspring("Chaotic", {{"Ethereal", "Supernatural"}})
 addOffspring("Brainy", {{"Skulking", "Pupil"}})
 addOffspring("Batty", {{"Skulking", "Windy"}})
 addOffspring("Poultry", {{"Common", "Skulking"}})
 addOffspring("Beefy", {{"Common", "Skulking"}})
 addOffspring("Porcine", {{"Common", "Skulking"}})
 addOffspring("Minium", {{"Frugal", "Eldritch"}})
 
 
 
 --find the highest level bee i own that is a parent to species (of type "Princess" or "Drone" if type ~= nil)
 --returns parent, offspring, score
 --offspring is the next step after parent
 --score is the depth of the search
 
 function findAvailableParent(species, score, type)
 
 	for i, stack in pairs(stacks) do
 		if stack.beeInfo.displayName == species then
 			if type then
 				if string.find(stack.name, type) then
 					return species, nil, score
 				end
 			else
 				return species, nil, score
 			end
 		end
 	end
 
 	local aScore, aParent, aOffspring
 	local beeScore = 99999
 	local beeParent = nil
 	local beeOffspring = nil
 
 	for i, parents in ipairs(bees[species].mutateFrom) do
 		aParent, aOffspring, aScore = findAvailableParent(parents[1], score + 1, type)
 		if aScore < beeScore then
 			beeScore = aScore
 			beeParent = aParent
 			beeOffspring = aOffspring
 		end
 		aParent, aOffspring, aScore = findAvailableParent(parents[2], score + 1, type)
 		if aScore < beeScore then
 			beeScore = aScore
 			beeParent = aParent
 			beeOffspring = aOffspring
 		end
 	end
 	if beeOffspring == nil then
 		beeOffspring = species
 	end
 	return beeParent, beeOffspring, beeScore
 end
 
 --finds a princess and drone of the given species if they exist
 local function findSpecies(species)
 	local princessIndex = nil
 	local droneIndex = nil
 
 	for i, stack in pairs(stacks) do
 		if stack.beeInfo.displayName == species then
 			if string.find(stack.name, "Princess") then
 				princessIndex = i
 			end
 			if string.find(stack.name, "Drone") then
 				droneIndex = i
 			end
 		end
 	end
 	return princessIndex, droneIndex
 end
 
 --breed these two species, they must exists and have a breeding pair
 local function breedSpecies(parent1, parent2)
 	local princess1 = nil
 	local princess2 = nil
 	local drone1 = nil
 	local drone2 = nil
 
 	princess1, drone1 = findSpecies(parent1)
 	princess2, drone2 = findSpecies(parent2)
 
 	if not (princess1 and drone2) then
 		princess1 = princess2
 		drone2 = drone1
 	end
 
-		chest.pushItem("up", princess1, 1) --todo check against description
+
 
-		chest.pushItem("up", drone2, 1) --todo check against description
+
 		chest.pushItem("up", princess1, 1)
 		turtle.drop()
 		chest.pushItem("up", drone2, 1)
 		turtle.drop()
 		return true
 	end
---finds the most common species of type
+
 end
 
 --finds the most common species of type Drone or Princess
 local function findExtraBee(type, msg)
 	local counts = {}
 	local bestcount = 0
 	local bestspecies = nil
 
 	for i, stack in pairs(stacks) do
 		if string.find(stack.name, type) then
 			if counts[stack.beeInfo.displayName] then
 				counts[stack.beeInfo.displayName] = counts[stack.beeInfo.displayName] + stack.qty
 			else
 				counts[stack.beeInfo.displayName] = stack.qty
 			end
 			if counts[stack.beeInfo.displayName] > bestcount then
 				bestcount = counts[stack.beeInfo.displayName]
 				bestspecies = stack.beeInfo.displayName
 			end
 		end
 	end
 	if bestcount < 2 then
 		shutdownMsg = "Need more " .. type .. "s!";
 	else
 		if msg == "Used" then
 			print("Used Extra " .. bestspecies .. " " .. type)
 		end
 	end
 	return bestspecies, bestcount
 end
 
 --attempt to create a princess and minDrones of species, which i own one of
 --returns true if already purebred, else begins a breeding cycle
 
 local function purebreed(species)
 	local princessCount = 0
 	local droneCount = 0
 
 	--count how many i have
 
 	for i, stack in pairs(stacks) do
 		if stack.beeInfo.displayName == species then
 			if string.find(stack.name, "Princess") then
 				princessCount = princessCount + stack.qty
 			end
 			if string.find(stack.name, "Drone") then
 				droneCount = droneCount + stack.qty
 			end
 		end
 	end
 
 	if princessCount >= 1 and droneCount >= minDrones then
 		return true
 	end
 
 	print("Attempting to purebreed " .. species)
 
 	if princessCount >= 1 and droneCount >= 1 then
 		breedSpecies(species, species)
 		return false
 	end
 
 	--find something to breed it with, an available parent, or an extra bee
 
 	local parent1, offspring, score
 	if(princessCount >= 1) then
 		parent1, offspring, score = findAvailableParent(species, 0, "Drone")
 		if score == 99999 then
 			parent1, score = findExtraBee("Drone", "Used")
 		else
 			--the purebreeding code sometimes gets stuck on low fertility bees
 			--local princess1, drone1 = findSpecies(parent1)
 			--if princess1 and drone2 and not purebreed(parent1) then
 			--	return false
 			--end
 		end
 	else
 		parent1, offspring, score = findAvailableParent(species, 0, "Princess")
 		if score == 99999 then
 			parent1, score = findExtraBee("Princess", "Used")
 		else
 			--local princess1, drone1 = findSpecies(parent1)
 			--if princess1 and drone2 and not purebreed(parent1) then
 			--	return false
 			--end
 		end
 	end
 	if shutdownMsg then
 		return false
 	end
 
 	breedSpecies(species, parent1)
 	return false
 end
 
 --the main breeding function
 --uses findavailableparent, then tries to create the designated offspring
 
 local function targetSpecies(species)
 	local parent1
 	local parent2 = nil
 
 	--find the highest level bee i have that is a parent to species
 	--offspring is the next step after parent on the way to species
 
 	local parent1, offspring, score = findAvailableParent(species, 0, nil)
 	if score == 0 then
 		--found species
 		return true
 	end
 	if score == 99999 then
 		shutdownMsg = "No available parents for " .. species
 		return false
 	end
 
 	print("Targeting Species " .. offspring)
 
 	local princess1, drone1 = findSpecies(parent1)
 	local princess2, drone2
 
 	--find which bee i need to breed parent1 with to get offspring, showing preference for bees that i own
 
 	for i, parents in ipairs(bees[offspring].mutateFrom) do
 		if parents[1] == parent1 then
 			princess2, drone2 = findSpecies(parents[2])
 			if (princess1 and drone2) or (princess2 and drone1) then
 				parent2 = parents[2]
 				break
 			end
 			if not parent2 then
 				parent2 = parents[2]
 			end
 			if princess2 or drone2 then
 				parent2 = parents[2]
 			end
 		end
 		if parents[2] == parent1 then
 			princess2, drone2 = findSpecies(parents[1])
 			if (princess1 and drone2) or (princess2 and drone1) then
 				parent2 = parents[1]
 				break
 			end
 			if not parent2 then
 				parent2 = parents[1]
 			end
 			if princess2 or drone2 then
 				parent2 = parents[1]
 			end
 		end
 
 	end
 
 	princess2, drone2 = findSpecies(parent2)
 
 	if (princess1 and drone2) or (princess2 and drone1) then
 		--i have both bees i need so breed it now
 		--the purebreeding code sometimes gets stuck on low fertility bees
 		--if princess1 and drone1 and not purebreed(parent1) then
 		--	return false
 		--end
 		--if princess2 and drone2 and not purebreed(parent2) then
 		--	return false
 		--end
 		breedSpecies(parent1, parent2)
 		return false
 	end
 
 	--i have the species but not princess or drone, so purebreed it
 	if princess2 or drone2 then
 		purebreed(parent2)
 		return false
 	end
 
 	--i dont have the species i need to breed with parent, so target it
 	targetSpecies(parent2)
 	return false
 end
 
 local function dropExtraDrones()
 
 	local species, count = findExtraBee("Drone", "Dropping")
 	shutdownMsg = nil
 
 	if count <= maxDrones then
 		return
 	end
 
 	for i, stack in pairs(stacks) do
 		if stack.beeInfo.displayName == species and string.find(stack.name, "Drone") then
 			chest.pushItem("up", i, 1)
 			turtle.dropUp()
 			count = count - 1
 			if count <= maxDrones then
 				return
 			end
 		end
 	end
 
 end
 
 local dropExtraItems()
 
 	for i, stack in pairs(stacks) do
 		if (not string.find(stack.name, "Drone")) and (not string.find(stack.name, "Princess")) then
 			chest.pushItem("up", i, stack.qty)
 			turtle.dropUp()
 		end
 	end
 
 end
 
 local function main(species)
 
 	for slot = 1, 16 do
 		if turtle.getItemCount(slot) > 0 then
 			turtle.select(slot)
 			turtle.dropDown()
 		end
 	end
 	turtle.select(1)
 
 	local apiarystacks
 
 	while(1) do
 
 		--test for breeding in progress
 		apiarystacks = apiary.getAllStacks()
 		while apiarystacks[1] do
 			sleep(1)
 			while(turtle.suck()) do
 				turtle.dropDown()
 			end
 
 			apiarystacks = apiary.getAllStacks()
 		end
 
 		--clear apiary
 		while(turtle.suck()) do
 			turtle.dropDown()
 		end
 
 		--get the list of all items in the chest
 		stacks = chest.getAllStacks()
 
 		if targetSpecies(species) then
 			if purebreed(species) then
 				shutdownMsg = "Breeding complete: " .. species
 			end
 		end
 
 		if(shutdownMsg) then
 			print(shutdownMsg)
 			break
 		end
 
 		dropExtraDrones()
 		dropExtraItems()
 
 		sleep(1)
 	end
 end
 
 local species = ...
 if species == nil then
 	print("Usage")
 	print("   programname species")
 	return
 end
 if bees[species] == nil then
 	print("Species does not exist in database")
 end
 
 main(species)