-- AE2Warehouse.lua
-- Original Author: Chuck Burgess (Refined Storage)
-- Authors: Wian Grobler / Louw Erasmus (Applied Energistics 2 Integration)
-- Updated: 2025-10-31
-- required in game:
-- Advanced Peripherals mod (for Colony Integrator and ME Bridge)
-- Applied Energistics 2 mod
-- ME Bridge must be connected to an AE2 network with storage and crafting capabilities
-- ME Bridge must be connected to a ComputerCraft computer
-- Colony Integrator must be connected to the same computer
local logFile = "AE2Warehouse.log"
local time_between_runs = 30
-- Initialize Monitor
-- see: https://www.computercraft.info/wiki/Advanced_Monitor
local monitor = peripheral.find("monitor")
if not monitor then error("Monitor not found.") end
monitor.setTextScale(0.5)
monitor.clear()
monitor.setCursorPos(1, 1)
monitor.setCursorBlink(false)
print("Monitor initialized.")
-- Initialize ME Bridge (for Applied Energistics 2)
-- see: https://docs.advanced-peripherals.de/peripherals/me_bridge/
local bridge = peripheral.find("meBridge")
if not bridge then error("ME Bridge not found.") end
print("ME Bridge initialized.")
-- Initialize Colony Integrator
-- see: https://docs.advanced-peripherals.de/peripherals/colony_integrator/
local colony = peripheral.find("colonyIntegrator")
if not colony then error("Colony Integrator not found.") end
if not colony.isInColony() then error("Colony Integrator is not in a colony.") end
print("Colony Integrator initialized.")
-- Establish the direction to transport the items into the Warehouse based on
-- where the entanglement block is sitting
local storage = peripheral.find("entangled:tile")
if not storage then error("Warehouse storage not found.") end
local direction = ""
local names = peripheral.getNames()
for _, pos in ipairs(names) do
if peripheral.getType(pos) == "entangled:tile" then
-- Determine the direction (top, bottom, left, right, front, back)
-- You may need to adjust this based on your setup
direction = pos
break
end
end
print("Warehouse storage initialized at: " .. direction)
----------------------------------------------------------------------------
-- FUNCTIONS
----------------------------------------------------------------------------
--[[
Check if a table is empty
@param self table - The table to check
@return boolean - True if empty, false otherwise
]]
function table.empty(self)
for _ in pairs(self) do
return false
end
return true
end
--[[
Write data to log file
@param file handle - File handle to write to
@param data table - Data to serialize and write
@param blockTop string - Header text
@param blockBottom string - Footer text
@return void
]]
function writeToLog(file, data, blockTop, blockBottom)
file:write("\n")
file:write(blockTop)
file:write("\n")
file:write(textutils.serialize(data, { allow_repetitions = true }))
file:write("\n")
file:write(blockBottom)
file:write("\n")
end
--[[
Filter out equipment/tool requests that shouldn't be auto-fulfilled
@param request table - The work request to check
@return boolean - True if should be processed, false if should be skipped
]]
function processWorkRequestItem(request)
-- Skip tools, armor, and weapons
local skipCategories = {
"tool", "sword", "axe", "pickaxe", "shovel", "hoe",
"helmet", "chestplate", "leggings", "boots",
"bow", "crossbow", "shield", "shears", "flint_and_steel"
}
if not request.item or not request.item.name then
return false
end
local itemName = request.item.name:lower()
for _, category in ipairs(skipCategories) do
if itemName:find(category) then
return false
end
end
return true
end
--[[
Print justified text on monitor
@param mon peripheral - Monitor peripheral
@param y number - Y coordinate (row)
@param pos string - Position: "left", "center", or "right"
@param text string - Text to display
@param textcolor number - Color code
@return void
]]
function mPrintRowJustified(mon, y, pos, text, textcolor)
local w, h = mon.getSize()
local bg = mon.getBackgroundColor()
mon.setTextColor(textcolor)
mon.setBackgroundColor(bg)
if pos == "center" then
local x = math.floor((w - #text) / 2) + 1
mon.setCursorPos(x, y)
mon.write(text)
elseif pos == "right" then
local x = w - #text + 1
mon.setCursorPos(x, y)
mon.write(text)
else -- left
mon.setCursorPos(1, y)
mon.write(text)
end
end
--[[
Display timer and day/night cycle on monitor
@param mon peripheral - Monitor peripheral
@param t number - Current time
@return void
]]
function displayTimer(mon, t)
local w, h = mon.getSize()
local now = textutils.formatTime(t, false)
local cycle = "Day"
local cycle_color = colors.yellow
local timer_color = colors.white
if t >= 18.0 or t < 6.0 then
cycle = "Night"
cycle_color = colors.blue
end
mPrintRowJustified(mon, h, "left", " " .. cycle, cycle_color)
mPrintRowJustified(mon, h, "right", now .. " ", timer_color)
end
--[[
Parse colonist data from request target string
@param colonist string - Colonist target string (e.g., "Builder John Doe")
@return table - Parsed colonist data
]]
function createColonistData(colonist)
local title_words = {}
local words_in_name = 0
local colonist_job = "Unknown"
local colonist_name = colonist or "Unknown"
if colonist and colonist ~= "" then
local word_count = 0
for word in colonist:gmatch("%S+") do
word_count = word_count + 1
table.insert(title_words, word)
end
if word_count >= 2 then
colonist_job = title_words[1]
table.remove(title_words, 1)
colonist_name = table.concat(title_words, " ")
words_in_name = word_count - 1
elseif word_count == 1 then
colonist_job = title_words[1]
colonist_name = title_words[1]
end
end
return {
fullName = colonist,
titleWords = title_words,
job = colonist_job,
name = colonist_name,
wordsInName = words_in_name
}
end
--[[
Get all work requests from colony and log them
@param colony peripheral - Colony integrator peripheral
@return table - List of processed work requests
]]
function getWorkRequestList(colony)
local requestList = {}
local workRequests = colony.getRequests()
local file = fs.open(logFile, "w")
for w in pairs(workRequests) do
writeToLog(file, workRequests[w], "--- Request start ---", "--- Request end ---")
local name = workRequests[w].name or "Unknown"
local colonist = createColonistData(workRequests[w].target)
local desc = workRequests[w].desc or ""
local item = {}
local items = workRequests[w].items
if items and not table.empty(items) then
item.name = items[1].name
if items[1].nbt then
item.nbt = items[1].nbt
end
end
local needed = workRequests[w].count or 0
local newRecord = {
name = name,
desc = desc,
needed = needed,
item = item,
colonist = colonist
}
table.insert(requestList, newRecord)
writeToLog(file, newRecord, "--- Record start ---", "--- Record end ---")
end
file:close()
return requestList
end
--[[
Display list of requests on monitor
@param mon peripheral - Monitor peripheral
@param listName string - Title of the list
@param itemList table - List of items to display
@param startRow number - Starting row position
@return number - Next available row
]]
function displayList(mon, listName, itemList, startRow)
local row = startRow
mPrintRowJustified(mon, row, "center", listName, colors.white)
row = row + 1
if table.empty(itemList) then
mPrintRowJustified(mon, row, "center", "(none)", colors.gray)
row = row + 1
else
for e in pairs(itemList) do
local record = itemList[e]
local text = string.format("%d/%d %s", record.provided or 0, record.needed, record.name)
mPrintRowJustified(mon, row, "left", text, record.color)
mPrintRowJustified(mon, row, "right", record.colonist.name .. " ", record.color)
row = row + 1
end
end
row = row + 1
return row
end
--[[
Scan and process work requests using AE2 ME Bridge
@param colony peripheral - Colony integrator
@param bridge peripheral - ME Bridge
@param mon peripheral - Monitor
@param warehouse_direction string - Direction to export items
@return void
]]
function scanWorkRequests(colony, bridge, mon, warehouse_direction)
local builder_list = {}
local nonbuilder_list = {}
local equipment_list = {}
local requestList = getWorkRequestList(colony)
print(string.format("Processing %d work requests...", #requestList))
for i, request in ipairs(requestList) do
local color = colors.red
local provided = 0
-- Skip equipment/tool requests
if not processWorkRequestItem(request) then
request.color = colors.gray
request.provided = 0
table.insert(equipment_list, request)
print(string.format("Skipped: %s (equipment)", request.name))
else
-- Prepare item detail for AE2
local itemDetail = {
name = request.item.name,
count = request.needed
}
if request.item.nbt then
itemDetail.nbt = request.item.nbt
end
-- Check if item exists in AE2 system
local success, itemsInSystem = pcall(function() return bridge.getItem(itemDetail) end)
if success and itemsInSystem and itemsInSystem.amount >= request.needed then
-- Sufficient items available - export them
local exportSuccess, exported = pcall(function()
return bridge.exportItem(itemDetail, warehouse_direction)
end)
if exportSuccess and exported and exported > 0 then
provided = exported
color = colors.green
print(string.format("Exported: %d %s", exported, request.name))
else
color = colors.red
print(string.format("Failed to export: %s", request.name))
end
elseif success and itemsInSystem and itemsInSystem.amount > 0 then
-- Partial amount - export what's available and craft the rest
local partialItem = {
name = request.item.name,
count = itemsInSystem.amount
}
if request.item.nbt then
partialItem.nbt = request.item.nbt
end
local exportSuccess, exportResult = pcall(function()
return bridge.exportItem(partialItem, warehouse_direction)
end)
if exportSuccess and exportResult then
provided = exportResult
print(string.format("Partial export: %d/%d %s", provided, request.needed, request.name))
end
-- Try to craft remaining
local craftItem = {
name = request.item.name,
count = request.needed - provided
}
if request.item.nbt then
craftItem.nbt = request.item.nbt
end
local craftingSuccess, isCrafting = pcall(function()
return bridge.isItemCrafting(craftItem)
end)
if craftingSuccess and not isCrafting then
pcall(function() bridge.craftItem(craftItem) end)
print(string.format("Started crafting: %d %s", craftItem.count, request.name))
end
color = colors.yellow
else
-- Item not available - try to craft
local craftingSuccess, isCrafting = pcall(function()
return bridge.isItemCrafting(itemDetail)
end)
if craftingSuccess and not isCrafting then
local craftSuccess = pcall(function() bridge.craftItem(itemDetail) end)
if craftSuccess then
print(string.format("Started crafting: %d %s", request.needed, request.name))
color = colors.yellow
else
print(string.format("Cannot craft: %s (no pattern or resources)", request.name))
color = colors.red
end
else
print(string.format("Already crafting: %s", request.name))
color = colors.yellow
end
end
request.color = color
request.provided = provided
-- Categorize by job
if request.colonist.job == "Builder" then
table.insert(builder_list, request)
else
table.insert(nonbuilder_list, request)
end
end
end
-- Display on monitor
monitor.clear()
monitor.setCursorPos(1, 1)
local row = 1
row = displayList(mon, "=== BUILDERS ===", builder_list, row)
row = displayList(mon, "=== NON-BUILDERS ===", nonbuilder_list, row)
row = displayList(mon, "=== EQUIPMENT (Skipped) ===", equipment_list, row)
displayTimer(mon, os.time())
print(string.format("Scan complete: %d builders, %d non-builders, %d equipment",
#builder_list, #nonbuilder_list, #equipment_list))
end
----------------------------------------------------------------------------
-- MAIN LOOP
----------------------------------------------------------------------------
print("Starting AE2 Warehouse automation...")
print("Press Ctrl+T to terminate")
local timer_id = os.startTimer(time_between_runs)
while true do
local event, param1 = os.pullEvent()
if event == "timer" and param1 == timer_id then
local currentTime = os.time()
-- Only process during day (6:00 AM to 6:00 PM)
if currentTime >= 6.0 and currentTime < 18.0 then
print("=== Starting scan at " .. textutils.formatTime(currentTime, false) .. " ===")
local success, err = pcall(function()
scanWorkRequests(colony, bridge, monitor, direction)
end)
if not success then
print("ERROR: " .. tostring(err))
monitor.clear()
monitor.setCursorPos(1, 1)
mPrintRowJustified(monitor, 1, "center", "=== ERROR ===", colors.red)
mPrintRowJustified(monitor, 2, "center", "Check computer console", colors.red)
displayTimer(monitor, currentTime)
end
else
monitor.clear()
monitor.setCursorPos(1, 1)
mPrintRowJustified(monitor, 1, "center", "=== NIGHT TIME ===", colors.blue)
mPrintRowJustified(monitor, 2, "center", "Requests paused until morning", colors.gray)
displayTimer(monitor, currentTime)
print("Night time - paused")
end
timer_id = os.startTimer(time_between_runs)
elseif event == "monitor_touch" then
-- Manual refresh on touch
print("=== Manual refresh triggered ===")
local success, err = pcall(function()
scanWorkRequests(colony, bridge, monitor, direction)
end)
if not success then
print("ERROR: " .. tostring(err))
end
timer_id = os.startTimer(time_between_runs)
elseif event == "terminate" then
print("Terminating program...")
monitor.clear()
monitor.setCursorPos(1, 1)
mPrintRowJustified(monitor, 1, "center", "=== TERMINATED ===", colors.red)
break
end
end
print("AE2 Warehouse automation stopped.")
