View difference between Paste ID: Pyusp5QA and aGpgGKEM

 -- Config
 
 local maxUsedSlotsPerCell = 55
 local paddingPercent = 100
 
 local systemDriveNames = {
   "appliedenergistics2:drive_28",
   "appliedenergistics2:drive_25",
 }
 local workspaceNames = {
   ioPort = "appliedenergistics2:io_port_8",
   interface = "appliedenergistics2:interface_7",
   chest = "appliedenergistics2:chest_7",
   drives = {
     "appliedenergistics2:drive_31",
     "appliedenergistics2:drive_30",
   }
 }
 
 local capacityByName = {
   ["appliedenergistics2:storage_cell_1k"] = 1024,
   ["appliedenergistics2:storage_cell_4k"] = 4096,
   ["appliedenergistics2:storage_cell_16k"] = 16384,
   ["appliedenergistics2:storage_cell_64k"] = 65536
 }
 
 -- /Config
 
 -- Util Functions
 
 local clock = os.clock
 local function sleep(n)  -- seconds
   local t0 = clock()
   while clock() - t0 <= n do end
 end
 
 local function map(array, func)
   local new_array = {}
   for i,v in pairs(array) do
     new_array[i] = func(v, i)
   end
   return new_array
 end
 
 local function values(obj)
   local result = {}
   for _, v in pairs(obj) do
     table.insert(result, v)
   end
   return result
 end
 
 local function groupBy(array, prop)
   local result = {}
   for _, element in pairs(array) do
     if element[prop] ~= nil then
       if result[element[prop]] == nil then
         result[element[prop]] = {}
       end
       table.insert(result[element[prop]], element)
     end
   end
   return result
 end
 
 -- /Util Functions
 
 -- Peripherals
 
 local systemDrives = map(systemDriveNames, function(driveName)
   return peripheral.wrap(driveName)
 end)
 local workspace = {
   ioPort = peripheral.wrap(workspaceNames.ioPort),
   interface = peripheral.wrap(workspaceNames.interface),
   chest = peripheral.wrap(workspaceNames.chest),
   drives = map(workspaceNames.drives, function(driveName)
     return peripheral.wrap(driveName)
   end)
 }
 
 -- /Peripherals
 
 -- Classes
 
 -- Cell
 
 local cells = {}
 local additionallyRequiredCells = {}
 local Cell = {}
 Cell.__index = Cell
 
 Cell.capacities = (function()
   local capacities = values(capacityByName)
   table.sort(capacities, function(a, b) return a < b end)
   return capacities
 end)()
 
 function Cell.sortByUnusedBytesDesc(a, b)
   return b:getNumUnusedBytes() < a:getNumUnusedBytes()
 end
 
 function Cell.sortByCapacity(a, b)
   return a.capacity < b.capacity
 end
 
 function Cell.sortByCapacityDesc(a, b)
   return b.capacity < a.capacity
 end
 
 function Cell.loadAll()
   for driveNum, systemDrive in ipairs(systemDrives) do
     local systemCells = systemDrive.list()
     local toSlotNum = 1
     for _, cell in pairs(systemCells) do
       table.insert(cells, Cell.new(capacityByName[cell.name], driveNum, toSlotNum))
       toSlotNum = toSlotNum + 1
     end
   end
   table.remove(cells, #cells)
 end
 
 function Cell.new(capacity, driveNum, slotNum)
   local self = setmetatable({}, Cell)
   self.capacity = capacity
   self.driveNum = driveNum
   self.slotNum = slotNum
   self.inventory = {}
   return self
 end
 
 function Cell.getSmallestCellNeededForStack(stack)
   for _, capacity in ipairs(Cell.capacities) do
     local cell = Cell.new(capacity)
     if cell:hasSpaceFor(stack) then
       return cell
     end
   end
 end
 
 function Cell:getNumUsedBytes()
   local bytesUsed = 0
   for _, stackData in pairs(self.inventory) do
     bytesUsed = bytesUsed + self:getBytesForStack(stackData)
   end
   return bytesUsed
 end
 
 function Cell:add(stack)
   table.insert(self.inventory, stack)
   if self:getNumUsedBytes() > self.capacity then
     error("Unexpected error: inventory has exceeded capacity")
   end
 end
 
 function Cell:getBytesForStack(stack)
   return (self.capacity / 128) + math.ceil(stack.count / 8)
 end
 
 function Cell:hasSpaceFor(stack)
   local bytesUsed = self:getNumUsedBytes()
   local hasEnoughBytes = bytesUsed + self:getBytesForStack(stack) < self.capacity
   local hasEnoughSlots = self:getNumUnusedSlots() > 0
   return hasEnoughBytes and hasEnoughSlots
 end
 
 function Cell:getNumUnusedBytes()
   return self.capacity - self:getNumUsedBytes()
 end
 
 function Cell:getNumUnusedSlots()
   return maxUsedSlotsPerCell - #self.inventory
 end
 
 function Cell:clearAndPutInWorkspaceChest()
   local drive = workspace.drives[self.driveNum]
   drive.pushItems(workspaceNames.ioPort, self.slotNum)
   while workspace.ioPort.list()[7] == nil do
     sleep(0.1)
   end
   workspace.ioPort.pushItems(workspaceNames.chest, 7)
 end
 
 function Cell:exportInventoryToWorkspaceChest()
   for _, stack in ipairs(self.inventory) do
     stack:exportToWorkspaceChest()
   end
 end
 
 local outputDrives = {}
 for _, drive in pairs(systemDrives) do
   table.insert(outputDrives, drive)
 end
 local currentOutputDrive = table.remove(outputDrives, 1)
 function Cell:moveBackToSystem()
   currentOutputDrive.pullItems(workspaceNames.chest, 2)
   if #currentOutputDrive.list() == 10 then
     currentOutputDrive = table.remove(outputDrives, 1)
   end
 end
 
 -- Stack
 
 local stacks = {}
 local Stack = {}
 Stack.__index = Stack
 
 function Stack.sortByCountDesc(a, b)
   return b.count < a.count
 end
 
 function Stack.loadAll()
   local handledItemTypes = {}
   local allItemTypes = workspace.interface.listAvailableItems()
   for _, itemType in pairs(allItemTypes) do
     if handledItemTypes[itemType.name] == nil then
       handledItemTypes[itemType.name] = 1
       local ccStacks = workspace.interface.findItems(itemType.name)
       for _, ccStack in pairs(ccStacks) do
         table.insert(stacks, Stack.new(ccStack))
       end
     end
   end
 end
 
 function Stack.new(ccStack)
   local self = setmetatable({}, Stack)
   self.ccStack = ccStack
   self.metadata = ccStack.getMetadata()
   self.displayName = self.metadata.displayName
   self.count = (1+paddingPercent/100)*self.metadata.count
   return self
 end
 
 function Stack:addToCellWithLargestUnusuedSpace()
   table.sort(cells, Cell.sortByUnusedBytesDesc)
   for _, cell in ipairs(cells) do
     if cell:hasSpaceFor(self) then
       cell:add(self)
       return
     end
   end
   local newCell = Cell.getSmallestCellNeededForStack(self)
   newCell:add(self)
   table.insert(cells, newCell)
   table.insert(additionallyRequiredCells, newCell)
   error("No cell found to add stack to")
 end
 
 function Stack:exportAllToWorkspaceChest()
   local amountToExport = self.metadata.count
   print("  Exporting "..amountToExport.." "..self.displayName.."...")
   local amountExported = 0
   while amountExported < amountToExport do
     amountExported = amountExported + self.ccStack.export(workspaceNames.chest)
   end
 end
 
 -- /Classes
 
 -- Main
 
 print("Scanning for cells...")
 Cell.loadAll()
 
 print("Moving cells to workspace...")
 local function moveDrivesFromSystemToWorkspace()
   for driveNum, systemDrive in ipairs(systemDrives) do
     local systemCells = systemDrive.list()
     for fromSlotNum, _ in pairs(systemCells) do
       systemDrive.pushItems(workspaceNames.drives[driveNum], fromSlotNum)
     end
   end
 end
 
 moveDrivesFromSystemToWorkspace()
 
 print("Scanning for stacks...")
 Stack.loadAll()
 
 print("Planning...")
 table.sort(stacks, Stack.sortByCountDesc)
 for _, stack in ipairs(stacks) do
   stack:addToCellWithLargestUnusuedSpace()
 end
 
 if #additionallyRequiredCells > 0 then
   print("Needed cells:")
   local requiredCellsByCapacity = groupBy(additionallyRequiredCells, 'capacity')
   for _, capacity in ipairs(Cell.capacities) do
     if requiredCellsByCapacity[capacity] ~= nil and #requiredCellsByCapacity[capacity] > 0 then
       print("  "..#requiredCellsByCapacity[capacity].." "..(capacity/1024).."k cells")
     end
   end
   error("Add the above cells to continue")
 end
 
 print("Executing plan...")
 
 table.sort(cells, Cell.sortByCapacity)
 
 for _, cell in ipairs(cells) do
   print("clearing and putting in workspace...")
   cell:clearAndPutInWorkspaceChest()
   print("moving stacks to chest...")
   for _, stack in ipairs(cell.inventory) do
     stack:exportAllToWorkspaceChest()
   end
   print("moving cell back to system...")
   cell:moveBackToSystem()
 end