Bee Breeding New test 2

-- BeeAlverizer 1 fork of BeeAnalyzer 4
-- Original code by Direwolf20
-- Hotfix 1 by Mandydax
-- Hotfix 2 by Mikeyhun/MaaadMike

-- Major overhaul to make work without turtle by Damaged

-- JSON lib loaded to debug arrays
local JSON = (loadfile "JSON.lua")()
JSON.strictTypes = true


-- Direction definitions.













-- attribute scoring for same species tie-breaking -----------------------------

local princessSlot = 0
alveary = peripheral.wrap("back")
memoryChest = peripheral.wrap("top")
local maxMem = memoryChest.getInventorySize()
-- Fix for some versions returning bees.species.*
function fixName(name)
   return name:gsub("bees%.species%.",""):gsub("^.", string.upper)
end

function getBeeData(i)
   return memoryChest.getStackInSlot(i)["beeInfo"]
end

function getPrimarySpecies(i)
   if getBeeData(i)["speciesPrimary"] then
      return fixName(getBeeData(i)["speciesPrimary"])
   else
      return fixName(getBeeData(i)["active"]["species"])
   end
end

function getSecondarySpecies(i)
   if getBeeData(i)["speciesSecondary"] then
      return fixName(getBeeData(i)["speciesSecondary"])
   else
      return fixName(getBeeData(i)["inactive"]["species"])
   end
end

scoresFertility = {
   [1] = 0.1,
   [2] = 0.2,
   [3] = 0.3,
   [4] = 0.4
}
scoresSpeed = {
   ["0.3"] = 0.01, -- Slowest
   ["0.6"] = 0.02, -- Slower
   ["0.8"] = 0.03, -- Slow
   ["1"]   = 0.04, -- Normal
   ["1.2"] = 0.05, -- Fast
   ["1.4"] = 0.06, -- Faster
   ["1.7"] = 0.07  -- Fastest
}
scoresAttrib = {
   diurnal       = 0.004,
   nocturnal     = 0.003,
   tolerantFlyer = 0.002,
   caveDwelling  = 0.0001
}
scoresTolerance = {
   ["NONE"]   = 0.00000,
   ["UP 1"]   = 0.00001,
   ["UP 2"]   = 0.00002,
   ["UP 3"]   = 0.00003,
   ["UP 4"]   = 0.00004,
   ["UP 5"]   = 0.00005,
   ["DOWN 1"] = 0.00001,
   ["DOWN 2"] = 0.00002,
   ["DOWN 3"] = 0.00003,
   ["DOWN 4"] = 0.00004,
   ["DOWN 5"] = 0.00005,
   ["BOTH 1"] = 0.00002,
   ["BOTH 2"] = 0.00004,
   ["BOTH 3"] = 0.00006,
   ["BOTH 4"] = 0.00008,
   ["BOTH 5"] = 0.00010
}

-- the bee graph ---------------------------------------------------------------

bees = {}

function addParent(parent, offspring)
   if bees[parent] then
      bees[parent].mutateTo[offspring] = true
      else
      bees[parent] = {
         --name = parent,
         score = nil,
         mutateTo = {[offspring]=true},
         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 = nil,
         mutateTo = {},
         mutateFrom = parentss
      }
   end
   for i, parents in ipairs(parentss) do
      for i, parent in ipairs(parents) do
         addParent(parent, offspring)
      end
   end
end

-- score bees that have no parent combinations as 1
-- iteratively find the next bee up the line and increase the score
function scoreBees()
   -- find all bees with no mutateFrom data
   local beeCount = 0
   local beeScore = 1
   for name, beeData in pairs(bees) do
      if #beeData.mutateFrom == 0 then
         beeData.score = beeScore
         else
         beeCount = beeCount + 1
      end
   end
   while beeCount > 0 do
      beeScore = beeScore * 2
      -- find all bees where all parent combos are scored
      for name, beeData in pairs(bees) do
         if not beeData.score then
            local scoreBee = true
            for i, beeParents in ipairs(beeData.mutateFrom) do
               local parent1 = bees[beeParents[1]]
               local parent2 = bees[beeParents[2]]

               if not parent1.score
                  or parent1.score == beeScore
                  or not parent2.score
                  or parent2.score == beeScore then
                  scoreBee = false
                  break
               end
            end
            if scoreBee then
               beeData.score = beeScore
               beeCount = beeCount - 1
            end
         end
      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


for key, value in pairs (alveary.getBeeBreedingData()) do
   addOffspring( fixName(value.result), {{ fixName(value.allele1), fixName(value.allele2) }} )
end
scoreBees()

-- logging ---------------------------------------------------------------------

local logFile = fs.open("bee.log", "w")
function log(msg)
   msg = msg or ""
   logFile.write(tostring(msg))
   logFile.flush()
   io.write(msg)
end
function logLine(msg)
   msg = msg or ""
   logFile.write(msg.."\n")
   logFile.flush()
   io.write(msg.."\n")
end

function logTable(table)
   for key, value in pairs (table) do
      logLine(key .. " = " .. tostring(value))
   end
end


-- analyzing functions ---------------------------------------------------------

function clearSystem()
   -- clear out alveary
   for i = 2,9 do
      memoryChest.pullItem("north",i)
   end
   -- clear out analyzer
   for i = 1, 12 do
      memoryChest.pullItem("west",i)
   end
end

function getBees()
   -- get bees from apiary
   log("waiting for bees.")
   while true do
      local gotStuff = false
      for i = 3,9 do
         if memoryChest.pullItem("north",i) ~= 0 then
            gotStuff = true
         end
      end
      if gotStuff == true then
         break
      end
      sleep(10)
      log(".")
   end
   log("*")
   logLine()
end

function analyzeBees()
   princessSlot = 0
   logLine("analyzing bees...")
   memoryChest.condenseItems()
   local highestScore
   local highestScoreDrone
   for i,data in pairs(memoryChest.getAllStacks()) do
      data = memoryChest.getStackInSlot(i)
      if not ( string.find(data["rawName"], "item.beedrone") or string.find(data["rawName"], "item.beeprincess") ) then
         memoryChest.pushItem("east",i)
         print("P")
      else
         print("B")
         --print(JSON:encode(data["beeInfo"]))
         --print(data["beeInfo"]["isAnalyzed"])
         if data["beeInfo"]["isAnalyzed"] == false then
            memoryChest.pushItemIntoSlot("west",i,64,3)
            while memoryChest.pullItemIntoSlot("west",9,61,i) == 0 do sleep(1) end
         end
         if string.find(data["rawName"], "princess") then
            if i ~= 1 then
               memoryChest.swapStacks(i,1)
            end
            princessSlot = 1
         end
         -- check for untargeted species
         if memoryChest.getStackInSlot(i) ~= nil and (not bees[getPrimarySpecies(i)].targeted or not bees[getSecondarySpecies(i)].targeted) then
            memoryChest.pushItem("east",i)
         end
      end
   end

   if princessSlot == 1 then
      logLine("compacting drones...")
      for i = 2, maxMem do
         if memoryChest.getStackInSlot(i) == nil then
            for key,data in pairs(memoryChest.getAllStacks()) do
               if key > i then
                  memoryChest.swapStacks(i, key)
                  break
               end
            end
         end
      end
      -- selection sort drones
      logLine("sorting drones...")
      for i = 2, maxMem do
         highestScoreDrone = i
         if memoryChest.getStackInSlot(i) ~= nil then
            highestScore = scoreBee(i)
            for key,data in pairs(memoryChest.getAllStacks()) do
               if key > 2 then
                  if scoreBee(key) > highestScore then
                     highestScoreDrone = key
                  end
               end
            end
            -- swap bees
            if highestScoreDrone ~= i then
               memoryChest.swapStacks(i, highestScoreDrone)
            end
         end
      end
      printHeader()
      for i = 1, maxMem do
         if memoryChest.getStackInSlot(i) ~= nil then
            printBee(i)
         end
      end
   end
   logLine()
end

function scoreBee(droneID)
   local beeDataDrone = getBeeData(droneID)
   local beeDataPrincess = getBeeData(princessSlot)
   local droneSpecies = {getPrimarySpecies(droneID), getSecondarySpecies(droneID)}
   -- check for untargeted species
   if not bees[droneSpecies[1]].targeted or not bees[droneSpecies[2]].targeted then
      return 0
   end
   local princessSpecies = {getPrimarySpecies(princessSlot), getSecondarySpecies(princessSlot)}
   local score
   local maxScore = 0
   for _, combo in ipairs({{princessSpecies[1], droneSpecies[1]}
      ,{princessSpecies[1], droneSpecies[2]}
      ,{princessSpecies[2], droneSpecies[1]}
   ,{princessSpecies[2], droneSpecies[2]}}) do
      -- find maximum score for each combo
      score = (bees[combo[1]].score + bees[combo[2]].score) / 2
      for name, beeData in pairs(bees) do
         if beeData.targeted then
            for i, parents in ipairs(beeData.mutateFrom) do
               if combo[1] == parents[1] and combo[2] == parents[2]
                  or combo[2] == parents[1] and combo[1] == parents[2] then
                  score = (score + beeData.score) / 2
               end
            end
         end
      end
      maxScore = maxScore + score
   end
   -- add one for each combination that results in the maximum score
   score = maxScore
   -- score attributes
   score = score + math.max(scoresFertility[beeDataDrone["active"]["fertility"]], scoresFertility[beeDataPrincess["active"]["fertility"]])
   score = score + math.min(scoresSpeed[tostring(beeDataDrone["active"]["speed"])], scoresSpeed[tostring(beeDataPrincess["active"]["speed"])])
   if beeDataDrone["active"]["nocturnal"] or beeDataPrincess["active"]["nocturnal"] then score = score + scoresAttrib["nocturnal"] end
   if beeDataDrone["active"]["tolerantFlyer"] or beeDataPrincess["active"]["tolerantFlyer"] then score = score + scoresAttrib["tolerantFlyer"] end
   if beeDataDrone["active"]["caveDwelling"] or beeDataPrincess["active"]["caveDwelling"] then score = score + scoresAttrib["caveDwelling"] end
   score = score + math.max(scoresTolerance[string.upper(beeDataDrone["active"]["temperatureTolerance"])], scoresTolerance[string.upper(beeDataPrincess["active"]["temperatureTolerance"])])
   score = score + math.max(scoresTolerance[string.upper(beeDataDrone["active"]["humidityTolerance"])], scoresTolerance[string.upper(beeDataPrincess["active"]["humidityTolerance"])])
   return score
end

function printHeader()
   logLine()
   logLine("sl t species f spd n f c tmp hmd score ")
   logLine("--|-|-------|-|---|-|-|-|---|---|------")
end

-- string constants for console output
toleranceString = {
   ["NONE"] = "  - ",
   ["UP 1"] = " +1 ",
   ["UP 2"] = " +2 ",
   ["UP 3"] = " +3 ",
   ["UP 4"] = " +4 ",
   ["UP 5"] = " +5 ",
   ["DOWN 1"] = " -1 ",
   ["DOWN 2"] = " -2 ",
   ["DOWN 3"] = " -3 ",
   ["DOWN 4"] = " -4 ",
   ["DOWN 5"] = " -5 ",
   ["BOTH 1"] = "+-1 ",
   ["BOTH 2"] = "+-2 ",
   ["BOTH 3"] = "+-3 ",
   ["BOTH 4"] = "+-4 ",
   ["BOTH 5"] = "+-5 "
}

speedString = {
   ["0.3"] = "0.3", -- Slowest
   ["0.6"] = "0.6", -- Slower
   ["0.8"] = "0.8", -- Slow
   ["1"]   = "1.0", -- Normal
   ["1.2"] = "1.2", -- Fast
   ["1.4"] = "1.4", -- Faster
   ["1.7"] = "1.7"  -- Fastest
}

function printBee(i)
   local beeData = getBeeData(i)
   log(i < 10 and " "..i.." " or i.." ")
   -- type
   log(string.find(memoryChest.getStackInSlot(i)["rawName"], "princess") and "P " or "D ")
   -- species
   log(getPrimarySpecies(i):gsub("bees%.species%.",""):sub(1,3)..":"..getSecondarySpecies(i):gsub("bees%.species%.",""):sub(1,3).." ")
   -- fertility
   log(tostring(beeData["active"]["fertility"]).." ")
   -- speed
   log(speedString[tostring(beeData["active"]["speed"])].." ")
   -- nocturnal
   log(beeData["active"]["nocturnal"] and "X " or "- ")
   -- flyer
   log(beeData["active"]["tolerantFlyer"] and "X " or "- ")
   -- cave dwelling
   log(beeData["active"]["caveDwelling"] and "X " or "- ")
   -- temperature tolerance
   log(toleranceString[string.upper(beeData["active"]["temperatureTolerance"])])
   -- humidity tolerance
   log(toleranceString[string.upper(beeData["active"]["humidityTolerance"])])
   -- score
   log(scoreBee(i) and string.format("%5.1d", scoreBee(i)).." " or "      ")
   logLine()
end

function dropExcess()
   logLine("dropping excess...")
   for i = ( maxMem - 9 ), maxMem do
      -- drop drones over ( max inv - 9 ) to clear space for newly bred bees and product
      memoryChest.pushItem("east",i)
   end
end

function isPurebred(droneID)
   -- check if princess and drone are exactly the same and no chance for mutation
   if getPrimarySpecies(princessSlot) ~= getSecondarySpecies(princessSlot) then
      return false
   end
   local droneData = getBeeData(droneID)
   local princessData = getBeeData(princessSlot)
   for i,key in pairs({ "fertility", "speed", "nocturnal", "tolerantFlyer", "caveDwelling", "temperatureTolerance", "humidityTolerance" }) do
      if
         droneData["active"][key] ~= princessData["active"][key] or
         droneData["inactive"][key] ~= princessData["inactive"][key]
      then
         return false
      end
   end

--   for key, value in pairs(getBeeData(princessSlot)) do
--      if value ~= getBeeData(droneID)[key] and key ~= "territory" then
--      end
--   end

   return true
end

-- targeting -------------------------------------------------------------------

-- set species and all parents to targeted
function targetBee(name)
   local bee = bees[name]
   if bee and not bee.targeted then
      bee.targeted = true
      for i, parents in ipairs(bee.mutateFrom) do
         for j, parent in ipairs(parents) do
            targetBee(parent)
         end
      end
   end
end

-- set bee graph entry to targeted if species was specified on the command line
-- otherwise set all entries to targeted
tArgs = { ... }
if #tArgs > 0 then
   logLine("targeting bee species:")
   for i, target in ipairs(tArgs) do
      targetBee(target)
      for name, data in pairs(bees) do
         if data.targeted and data.score > 1 then
            logLine(name .. string.rep(" ", 20-#name), data.score)
         end
      end
   end
   else
   for _, beeData in pairs(bees) do
      beeData.targeted = true
   end
end

-- breeding loop ---------------------------------------------------------------

logLine("Clearing system...")
clearSystem()
if not memoryChest.getAllStacks() then
   print("No bees to work on, add bees and restart")
else
   redstone.setOutput("bottom", true)
   while true do
      analyzeBees()
      if princessSlot == 1 then
         if isPurebred(2) then
            logLine("Bees are purebred")
            redstone.setOutput("bottom", false)
            break
         end
         memoryChest.pushItemIntoSlot("north",1,1,1)
         memoryChest.pushItemIntoSlot("north",2,1,2)
         dropExcess()
      end
      getBees()
   end
end
logFile.close()