Minecraft ComputerCraft Modem GeologistManager

--
-- Desc: An Unearther Geologist manager program for FTB Stoneblock 4
-- Manages the Geologist with specific slot handling:
-- Slot 1: Material input (soul sand, gravel, crushed kivi)
-- Slot 2: Food (optional, improves processing speed)
-- Slot 3: Brush (required, auto-supplied from inventory)
-- Slots 4-12: Output slots (carefully managed to avoid disrupting hidden token slot)
-- IMPORTANT!: as you connect modems to geologists/chests, update the config to match
-- their names, or this will not work correctly.
--

-- By: hornedcommando

-- =========================
-- ========== CONFIG =======
-- =========================
local CONFIG = {
  -- Your Unearther Geologist peripheral name
  geologist = "ftbunearthed:frame_0",

  -- by default inputs where their outputs > 128 are trashed here, leave as nil to disable
  trashPeripheral = "trashcans:item_trash_can_tile_1",

  -- Optional: a fallback output chest if no merge target exists
  fallbackOutputChest = "ironchest:crystal_chest_0",

  -- Brush priority order (best to worst)
  brushes = {
    "ftbunearthed:unbreakable_brush",
    "ftbunearthed:reinforced_brush",
    "minecraft:brush",
    "ftbunearthed:crude_brush"
  },

  -- Food items that can be used in slot 2
  foods = {
    "minecraft:bread",
    "minecraft:cooked_beef",
    "minecraft:cooked_porkchop",
    "minecraft:cooked_chicken",
    "minecraft:apple",
    "minecraft:baked_potato"
  },

  -- Inputs and their outputs (used for balance comparisons).
  -- change this if your modpack has different geologist recipes
  inputs = {
    ["minecraft:soul_sand"] = {
      outputs = {
        "minecraft:glowstone_dust",
        "minecraft:quartz",
        "actuallyadditions:black_quartz"
      }
    },

    ["minecraft:gravel"] = {
      outputs = {
        "ftbmaterials:iron_chunk",
        "minecraft:coal",
        "minecraft:lapis_lazuli",
        "ftbmaterials:lead_chunk",
        "ftbmaterials:aluminum_chunk",
        "ftbmaterials:osmium_chunk",
        "minecraft:emerald",
        "minecraft:diamond",
      }
    },

    ["ftb:crushed_kivi"] = {
      outputs = {
        "xycraft_world:xychorium_gem_light",
        "xycraft_world:xychorium_gem_dark",
        "xycraft_world:xychorium_gem_blue",
        "xycraft_world:xychorium_gem_green",
        "xycraft_world:xychorium_gem_red",
      }
    },

},

  -- Balancer thresholds
  scarceLT = 9,      -- <9 scarce
  availLE = 64,      -- 9..64 available
  abundLE = 128,     -- 64..128 abundant
  reserveCount = 8,  -- keep at least this many of the INPUT unprocessed in Case #2

  -- Push/pull parameters
  maxPushPerCycle = 9,         -- conservative push to prevent depleting scarce resources
  maxOutputPullPerCycle = 512, -- cap pulls per loop to avoid huge bursts

  -- Sleep timings
  sleepShort = 2,   -- after any action
  sleepIdle = 5,    -- when nothing to do
  sleepError = 5,   -- on warnings

  -- Logging
  verbose = true,
}

-- =========================
-- ====== UTILITIES ========
-- =========================
local function log(...)
  if CONFIG.verbose then
    local t = {}
    for i = 1, select("#", ...) do t[#t+1] = tostring(select(i, ...)) end
    print(table.concat(t))
  end
end

local function isInv(name)
  if not peripheral.isPresent(name) then return false end
  local m = peripheral.getMethods(name) or {}
  local has = {}
  for _,x in ipairs(m) do has[x] = true end
  return has.list and (has.pushItems or has.pullItems)
end

local function allInventories()
  local out = {}
  for _,n in ipairs(peripheral.getNames()) do
    if isInv(n) then table.insert(out, n) end
  end
  table.sort(out)
  return out
end

local function list(name)
  local ok, res = pcall(function() return peripheral.call(name, "list") end)
  if ok and type(res) == "table" then return res end
  return {}
end
local function getItemDetail(name, slot)
  local ok, d = pcall(function() return peripheral.call(name, "getItemDetail", slot) end)
  if ok then return d end
  return nil
end

local function maxCountFor(name, slot)
  local d = getItemDetail(name, slot)
  if d and d.maxCount then return d.maxCount end
  return 64
end

local function countInInv(name, id)
  local total = 0
  for _, it in pairs(list(name)) do
    if it.name == id then total = total + (it.count or 0) end
  end
  return total
end

local function countAcrossNetwork(id, invs)
  local total = 0
  for _, n in ipairs(invs) do
    total = total + countInInv(n, id)
  end
  return total
end
local function stacksAcrossNetwork(id, invs, exclude)
  local out = {}
  for _, n in ipairs(invs) do
    if n ~= exclude then
      for slot, it in pairs(list(n)) do
        if it.name == id and (it.count or 0) > 0 then
          table.insert(out, { periph = n, slot = slot, count = it.count })
        end
      end
    end
  end
  return out
end

local function invFreeSlots(name)
  local okS, size = pcall(function() return peripheral.call(name, "size") end)
  if not okS or type(size) ~= "number" then return 0 end
  local used = 0
  for _ in pairs(list(name)) do used = used + 1 end
  return math.max(0, size - used)
end

local function canReach(src, dst)
  local ok, err = pcall(function() peripheral.call(src, "pushItems", dst, 1, 0) end)
  if ok then return true end
  local msg = tostring(err or "")
  if msg:find("does not exist") or msg:find("No such peripheral") then return false end
  return true
end

-- Prefer an inventory that already has the item, else fallback chest, else max free slots
local function chooseOutputTarget(itemId, invs, geologist, fallback)
  local best, bestCount = nil, -1
  for _, n in ipairs(invs) do
    if n ~= geologist then
      local c = countInInv(n, itemId)
      if c > 0 and canReach(geologist, n) then
        if c > bestCount then best, bestCount = n, c end
      end
    end
  end
  if best then return best end
  if fallback and fallback ~= geologist and canReach(geologist, fallback) then return fallback end
  -- else pick most free slots
  local mfName, mf = nil, -1
  for _, n in ipairs(invs) do
    if n ~= geologist and canReach(geologist, n) then
      local free = invFreeSlots(n)
      if free > mf then mfName, mf = n, free end
    end
  end
  return mfName
end

local function classify(amount)
  if amount < CONFIG.scarceLT then return "scarce"
  elseif amount <= CONFIG.availLE then return "available"
  elseif amount <= CONFIG.abundLE then return "abundant"
  else return "trash" end
end

local function sumCounts(ids, invs)
  local t = 0
  for _, id in ipairs(ids) do
    t = t + countAcrossNetwork(id, invs)
  end
  return t
end

local function outputsStatus(outputs, invs, classifyFn)
  local per = {}
  local allAbundant = true
  local anyBelowAbundant = false
  local anyScarce = false

  for _, oid in ipairs(outputs or {}) do
    local c = countAcrossNetwork(oid, invs)
    local b = classifyFn(c) -- uses CONFIG thresholds
    per[oid] = { count = c, band = b }

    if b == "scarce" or b == "available" then
      anyBelowAbundant = true
    end
    if b == "scarce" then
      anyScarce = true
    end
    if b ~= "abundant" and b ~= "trash" then
      allAbundant = false
    end
  end

  -- If there are no outputs mapped, treat as "unknown" => do not block processing
  if not outputs or #outputs == 0 then
    allAbundant = false
    anyBelowAbundant = true
  end

  return per, allAbundant, anyBelowAbundant, anyScarce
end

-- =========================
-- ===== CORE ACTIONS ======
-- =========================

-- Ensure slot 2 has food if available and slot is empty
local function manageFoodSlot(geologist, invs)
  local geoList = list(geologist)
  local slot2 = geoList[2]

  -- If slot 2 is empty or has very little food, try to add more
  if not slot2 or slot2.count < 5 then
    for _, foodId in ipairs(CONFIG.foods) do
      local stacks = stacksAcrossNetwork(foodId, invs, geologist)
      for _, st in ipairs(stacks) do
        if st.count > 16 then -- Only use food if we have plenty
          local ok, moved = pcall(function()
            return peripheral.call(st.periph, "pushItems", geologist, st.slot, math.min(16, st.count), 2)
          end)
          if ok and moved and moved > 0 then
            log("[FOOD] Added ", moved, " ", foodId, " to slot 2")
            return true
          end
        end
      end
    end
  end
  return false
end

-- Ensure slot 3 has a brush
local function manageBrushSlot(geologist, invs)
  local geoList = list(geologist)
  local slot3 = geoList[3]

  -- If slot 3 is empty, find a brush
  if not slot3 then
    for _, brushId in ipairs(CONFIG.brushes) do
      local stacks = stacksAcrossNetwork(brushId, invs, geologist)
      for _, st in ipairs(stacks) do
        local ok, moved = pcall(function()
          return peripheral.call(st.periph, "pushItems", geologist, st.slot, 1, 3)
        end)
        if ok and moved and moved > 0 then
          log("[BRUSH] Added ", brushId, " to slot 3")
          return true
        end
      end
    end
    log("[WARN] No brush found in inventory!")
    return false
  end
  return true
end

local function pushToGeologist(fromStacks, geologist, maxToPush)
  local remain = maxToPush
  local movedTotal = 0
  for _, st in ipairs(fromStacks) do
    if remain <= 0 then break end
    local move = math.min(remain, st.count)
    local ok, movedOrErr = pcall(function()
      -- Push to slot 1 (material slot)
      return peripheral.call(st.periph, "pushItems", geologist, st.slot, move, 1)
    end)
    if ok and type(movedOrErr) == "number" and movedOrErr > 0 then
      remain = remain - movedOrErr
      movedTotal = movedTotal + movedOrErr
      log("[GEOLOGIST] Pushed ", movedOrErr, " from ", st.periph, " -> ", geologist, " slot 1")
    else
      log("[WARN] push to geologist failed from ", st.periph, ": ", tostring(movedOrErr))
    end
  end
  return movedTotal
end

local function pullOutputsFromGeologist(geologist, invs, inputsSet)
  local lst = list(geologist)
  local pulled = 0
  local pulledItems = {}

  -- Only pull from output slots 4-12, avoid disrupting other slots
  for slot = 4, 12 do
    local it = lst[slot]
    if it and it.name then
      local id = it.name
      local isInput = inputsSet[id] == true
      local isBrush = false
      local isFood = false

      -- Check if this is a brush
      for _, brushId in ipairs(CONFIG.brushes) do
        if id == brushId then isBrush = true break end
      end

      -- Check if this is food
      for _, foodId in ipairs(CONFIG.foods) do
        if id == foodId then isFood = true break end
      end

      -- Only move items that are actual outputs (not inputs, brushes, or food)
      if (not isInput) and (not isBrush) and (not isFood) and it.count > 0 then
        local dest = chooseOutputTarget(id, invs, geologist, CONFIG.fallbackOutputChest)
        if dest then
          local moved = peripheral.call(geologist, "pushItems", dest, slot, it.count)
          if moved and moved > 0 then
            pulled = pulled + moved
            pulledItems[id] = (pulledItems[id] or 0) + moved
            log("[ROUTE] ", id, " x", moved, " from slot ", slot, " -> ", dest)
          end
        else
          log("[WARN] No reachable output destination for ", id, " (holding in geologist slot ", slot, " for now)")
        end
      end
    end
  end

  return pulled, pulledItems
end

local function disposeExcessInput(inputId, overAmount, invs, geologist, trash)
  if not trash or not peripheral.isPresent(trash) then return 0 end
  if overAmount <= 0 then return 0 end
  local stacks = stacksAcrossNetwork(inputId, invs, geologist)
  local remaining = overAmount
  local disposed = 0
  for _, st in ipairs(stacks) do
    if remaining <= 0 then break end
    local move = math.min(remaining, st.count)
    local ok, movedOrErr = pcall(function()
      return peripheral.call(st.periph, "pushItems", trash, st.slot, move)
    end)
    if ok and type(movedOrErr) == "number" and movedOrErr > 0 then
      remaining = remaining - movedOrErr
      disposed = disposed + movedOrErr
      log("[TRASH] ", inputId, " x", movedOrErr, " from ", st.periph, " -> ", trash)
    else
      log("[WARN] Dispose failed from ", st.periph, " -> ", trash, ": ", tostring(movedOrErr))
    end
  end
  return disposed
end

-- =========================
-- ====== MAIN LOOP ========
-- =========================
local function tick()
  local geologist = CONFIG.geologist
  if not peripheral.isPresent(geologist) then
    log("[WARN] Geologist not present: ", geologist)
    sleep(CONFIG.sleepError)
    return
  end

  local invs = allInventories()
  if #invs == 0 then
    log("[INFO] No inventories on network.")
    sleep(CONFIG.sleepIdle)
    return
  end

  -- Manage food and brush slots first
  manageFoodSlot(geologist, invs)
  manageBrushSlot(geologist, invs)

  -- Build a set of input IDs for quick checks
  local inputsSet, recipeOrder = {}, {}
  for inputId, _ in pairs(CONFIG.inputs) do
    inputsSet[inputId] = true
    table.insert(recipeOrder, inputId)
  end
  table.sort(recipeOrder)

  local didSomething = false

  for _, inputId in ipairs(recipeOrder) do
    local recipe = CONFIG.inputs[inputId]
    local outputs = recipe.outputs or {}
    local inputCount = countAcrossNetwork(inputId, invs)
    if inputCount <= 0 then
      log("[SKIP] No input found: ", inputId)
      goto continue_input
    end

    local inputBand = classify(inputCount)
    local per, allAbundant, anyBelowAbundant = outputsStatus(outputs, invs, classify)

    -- Debug snapshot
    do
      local dbg = {}
      for oid, st in pairs(per) do
        table.insert(dbg, (oid .. "=" .. st.count .. "(" .. st.band .. ")"))
      end
      table.sort(dbg)
      log(string.format("[EVAL] %s input=%d(%s) | outputs: %s",
        inputId, inputCount, inputBand, table.concat(dbg, ", ")))
    end

    -- Decision rules:

    if inputBand == "scarce" then
      -- Rule: scarce inputs are preserved (don't process)
      log("[HOLD] Scarce input, skipping: ", inputId)

    elseif inputBand == "available" then
      -- Process only if ANY output is below abundant
      if anyBelowAbundant then
        local stacks = stacksAcrossNetwork(inputId, invs, geologist)
        -- Reserve a floor of input; process only what's above reserve
        local pushBudget = math.max(0, inputCount - CONFIG.reserveCount)
        pushBudget = math.min(pushBudget, CONFIG.maxPushPerCycle)
        if pushBudget > 0 then
          local moved = pushToGeologist(stacks, geologist, pushBudget)
          if moved > 0 then didSomething = true end
        else
          log("[OK] Reserve intact; nothing to push for ", inputId)
        end
      else
        log("[OK] All outputs already abundant; skipping processing for ", inputId)
      end
    elseif inputBand == "abundant" then
      -- Only process if ANY output is below trash level (< 128)
      local anyNeedsProcessing = false
      for _, oid in ipairs(outputs or {}) do
        local c = countAcrossNetwork(oid, invs)
        local b = classify(c)
        if b == "scarce" or b == "available" or b == "abundant" then
          anyNeedsProcessing = true
          break
        end
      end

      if anyNeedsProcessing then
        local stacks = stacksAcrossNetwork(inputId, invs, geologist)
        local moved = pushToGeologist(stacks, geologist, CONFIG.maxPushPerCycle)
        if moved > 0 then didSomething = true end
      else
        log("[OK] All outputs at trash level; nothing to process for ", inputId)
      end

    else -- inputBand == "trash" (> 128)
      -- Check if any outputs are still below trash level
      local anyNeedsProcessing = false
      for _, oid in ipairs(outputs or {}) do
        local c = countAcrossNetwork(oid, invs)
        local b = classify(c)
        if b == "scarce" or b == "available" or b == "abundant" then
          anyNeedsProcessing = true
          break
        end
      end

      if anyNeedsProcessing then
        -- Still need outputs: process rather than dispose
        local stacks = stacksAcrossNetwork(inputId, invs, geologist)
        local moved = pushToGeologist(stacks, geologist, CONFIG.maxPushPerCycle)
        if moved > 0 then didSomething = true end
      else
        -- All outputs at trash level: safe to dispose input above 128 if trash is configured
        if CONFIG.trashPeripheral then
          local over = inputCount - CONFIG.abundLE
          if over > 0 then
            local disposed = disposeExcessInput(inputId, over, invs, geologist, CONFIG.trashPeripheral)
            if disposed > 0 then didSomething = true end
          else
            log("[OK] No excess to dispose for ", inputId)
          end
        else
          log("[OK] Would dispose excess of ", inputId, " but no trash configured")
        end
      end
    end

    ::continue_input::
  end

  -- After any pushes, pull outputs once to clear machine buffers
  local pulled, pulledItems = pullOutputsFromGeologist(geologist, invs, inputsSet)
  if pulled > 0 then
    didSomething = true
  end

  if didSomething then
    sleep(CONFIG.sleepShort)
  else
    sleep(CONFIG.sleepIdle)
  end
end

local function main()
  print("Unearther Geologist Manager starting...")
  while true do
    tick()
  end
end

main()