plethora networked autocrafting

apis/chestAdapter18.lua

@@ -122,6 +122,8 @@ function ChestAdapter:getPercentUsed()
 end
 
 function ChestAdapter:provide(item, qty, slot, direction)
+  local total = 0
+
   local s, m = pcall(function()
     local stacks = self.list()
     for key,stack in Util.rpairs(stacks) do
@@ -130,24 +132,25 @@ function ChestAdapter:provide(item, qty, slot, direction)
         (not item.nbtHash or stack.nbtHash == item.nbtHash) then
         local amount = math.min(qty, stack.count)
         if amount > 0 then
-          self.pushItems(direction or self.direction, key, amount, slot)
+          amount = self.pushItems(direction or self.direction, key, amount, slot)
         end
         qty = qty - amount
+        total = total + amount
         if qty <= 0 then
           break
         end
       end
     end
   end)
-  return s, m
+  return total, m
 end
 
 function ChestAdapter:extract(slot, qty, toSlot)
-  self.pushItems(self.direction, slot, qty, toSlot)
+  return self.pushItems(self.direction, slot, qty, toSlot)
 end
 
 function ChestAdapter:insert(slot, qty, toSlot)
-  self.pullItems(self.direction, slot, qty, toSlot)
+  return self.pullItems(self.direction, slot, qty, toSlot)
 end
 
 return ChestAdapter

inventoryManager/.package

@@ -0,0 +1,12 @@
+{
+	required = {
+		'opus-inventory-manager',
+	},
+	title = 'Inventory manager for Opus OS',
+	description = [[
+Unstable Branch
+]],
+	licence = 'MIT',
+	--location = '',
+	--mount = 'packages/opus-neural gitfs kepler155c/opus-neural/master',
+}

inventoryManager/apis/craft.lua

@@ -0,0 +1,319 @@
+local itemDB = require('itemDB')
+local Util   = require('util')
+
+local fs     = _G.fs
+local turtle = _G.turtle
+
+local RECIPES_DIR  = 'usr/etc/recipes'
+local USER_RECIPES = 'usr/config/recipes.db'
+
+local Craft = { }
+
+local function clearGrid(inventoryAdapter)
+	for i = 1, 16 do
+		local count = turtle.getItemCount(i)
+		if count > 0 then
+			inventoryAdapter:insert(i, count)
+			if turtle.getItemCount(i) ~= 0 then
+				-- inventory is possibly full
+				return false
+			end
+		end
+	end
+	return true
+end
+
+local function splitKey(key)
+	local t = Util.split(key, '(.-):')
+	local item = { }
+	if #t[#t] > 8 then
+		item.nbtHash = table.remove(t)
+	end
+	item.damage = tonumber(table.remove(t))
+	item.name = table.concat(t, ':')
+	return item
+end
+
+function Craft.getItemCount(items, item)
+	if type(item) == 'string' then
+		item = splitKey(item)
+	end
+
+	local count = 0
+	for _,v in pairs(items) do
+		if v.name == item.name and
+			 (not item.damage or v.damage == item.damage) and
+			 v.nbtHash == item.nbtHash then
+			if item.damage then
+				return v.count
+			end
+			count = count + v.count
+		end
+	end
+	return count
+end
+
+local function turtleCraft(recipe, qty, inventoryAdapter)
+	if not clearGrid(inventoryAdapter) then
+		return false
+	end
+
+	for k,v in pairs(recipe.ingredients) do
+		local item = splitKey(v)
+		local provideQty = qty
+		--[[
+		Turtles can only craft 1 item at a time when using a tool.
+
+		if recipe.craftingTools and recipe.craftingTools[k] then
+			provideQty = 1
+		end
+		]]--
+		inventoryAdapter:provide(item, provideQty, k)
+		if turtle.getItemCount(k) == 0 then -- ~= qty then
+																				-- FIX: ingredients cannot be stacked
+--debug('failed ' .. v .. ' - ' .. provideQty)
+			return false
+		end
+	end
+
+	return turtle.craft()
+end
+
+function Craft.loadRecipes()
+	Craft.recipes = { }
+
+	Util.merge(Craft.recipes, (Util.readTable(fs.combine(RECIPES_DIR, 'minecraft.db')) or { }).recipes)
+
+	local config = Util.readTable('usr/config/recipeBooks.db') or { }
+	for _, book in pairs(config) do
+		local recipeFile = Util.readTable(book)
+		Util.merge(Craft.recipes, recipeFile.recipes)
+	end
+
+	local recipes = Util.readTable(USER_RECIPES) or { }
+	Util.merge(Craft.recipes, recipes)
+end
+
+function Craft.sumIngredients(recipe)
+	-- produces { ['minecraft:planks:0'] = 8 }
+	local t = { }
+	for _,item in pairs(recipe.ingredients) do
+		t[item] = (t[item] or 0) + 1
+	end
+-- need a check for crafting tool
+	return t
+end
+
+function Craft.craftRecipe(recipe, count, inventoryAdapter)
+	if type(recipe) == 'string' then
+		recipe = Craft.recipes[recipe]
+		if not recipe then
+			return 0, 'No recipe'
+		end
+	end
+
+	local items = inventoryAdapter:listItems()
+	if not items then
+		return 0, 'Inventory changed'
+	end
+
+	count = math.ceil(count / recipe.count)
+	local maxCount = recipe.maxCount or math.floor(64 / recipe.count)
+
+	for key,icount in pairs(Craft.sumIngredients(recipe)) do
+		local itemCount = Craft.getItemCount(items, key)
+		local need = icount * count
+		if recipe.craftingTools and recipe.craftingTools[key] then
+			need = 1
+		end
+		maxCount = math.min(maxCount, itemDB:getMaxCount(key))
+		if itemCount < need then
+			local irecipe = Craft.findRecipe(key)
+			if irecipe then
+				local iqty = need - itemCount
+				local crafted = Craft.craftRecipe(irecipe, iqty, inventoryAdapter)
+				if crafted ~= iqty then
+					turtle.select(1)
+					return 0
+				end
+			end
+		end
+	end
+
+	local crafted = 0
+	repeat
+		if not turtleCraft(recipe, math.min(count, maxCount), inventoryAdapter) then
+			turtle.select(1)
+			break
+		end
+		crafted = crafted + math.min(count, maxCount)
+		count = count - maxCount
+	until count <= 0
+
+	turtle.select(1)
+	return crafted * recipe.count
+end
+
+local function makeRecipeKey(item)
+	if type(item) == 'string' then
+		item = splitKey(item)
+	end
+	return table.concat({ item.name, item.damage or 0, item.nbtHash }, ':')
+end
+
+function Craft.findRecipe(key)
+	if type(key) ~= 'string' then
+		key = itemDB:makeKey(key)
+	end
+
+	local item = itemDB:splitKey(key)
+	if item.damage then
+		return Craft.recipes[makeRecipeKey(item)]
+	end
+
+	-- handle cases where the request is like : IC2:reactorVent:*
+	for rkey,recipe in pairs(Craft.recipes) do
+		local r = itemDB:splitKey(rkey)
+		if item.name == r.name and
+			 (not item.nbtHash or r.nbtHash == item.nbtHash) then
+			 return recipe
+		end
+	end
+end
+
+-- determine the full list of ingredients needed to craft
+-- a quantity of a recipe.
+function Craft.getResourceList(inRecipe, items, inCount)
+	local summed = { }
+
+	local function sumItems(recipe, key, count)
+		local item = itemDB:splitKey(key)
+		local summedItem = summed[key]
+		if not summedItem then
+			summedItem = Util.shallowCopy(item)
+			summedItem.recipe = Craft.findRecipe(key)
+			summedItem.count = Craft.getItemCount(items, item)
+			summedItem.displayName = itemDB:getName(item)
+			summedItem.total = 0
+			summedItem.need = 0
+			summedItem.used = 0
+			summed[key] = summedItem
+		end
+		local total = count
+		local used = math.min(summedItem.count, total)
+		local need = total - used
+
+		if recipe.craftingTools and recipe.craftingTools[key] then
+			summedItem.total = 1
+			if summedItem.count > 0 then
+				summedItem.used = 1
+				summedItem.need = 0
+				need = 0
+			elseif not summedItem.recipe then
+				summedItem.need = 1
+				need = 1
+			else
+				need = 1
+			end
+		else
+			summedItem.total = summedItem.total + total
+			summedItem.count = summedItem.count - used
+			summedItem.used = summedItem.used + used
+			if not summedItem.recipe then
+				summedItem.need = summedItem.need + need
+			end
+		end
+
+		if need > 0 and summedItem.recipe then
+			need = math.ceil(need / summedItem.recipe.count)
+			for ikey,iqty in pairs(Craft.sumIngredients(summedItem.recipe)) do
+				sumItems(summedItem.recipe, ikey, math.ceil(need * iqty))
+			end
+		end
+	end
+
+	inCount = math.ceil(inCount / inRecipe.count)
+	for ikey,iqty in pairs(Craft.sumIngredients(inRecipe)) do
+		sumItems(inRecipe, ikey, math.ceil(inCount * iqty))
+	end
+
+	return summed
+end
+
+function Craft.getResourceList4(inRecipe, items, count)
+	local summed = Craft.getResourceList(inRecipe, items, count)
+-- filter down to just raw materials
+	return Util.filter(summed, function(a) return a.used > 0 or a.need > 0 end)
+end
+
+-- given a certain quantity, return how many of those can be crafted
+function Craft.getCraftableAmount(inRecipe, count, items, missing)
+	local function sumItems(recipe, summedItems, count)
+		local canCraft = 0
+
+		for _ = 1, count do
+			for _,item in pairs(recipe.ingredients) do
+				local summedItem = summedItems[item] or Craft.getItemCount(items, item)
+
+				local irecipe = Craft.findRecipe(item)
+				if irecipe and summedItem <= 0 then
+					summedItem = summedItem + sumItems(irecipe, summedItems, 1)
+				end
+				if summedItem <= 0 then
+					if missing and not irecipe then
+						missing.name = item
+					end
+					return canCraft
+				end
+				if not recipe.craftingTools or not recipe.craftingTools[item] then
+					summedItems[item] = summedItem - 1
+				end
+			end
+			canCraft = canCraft + recipe.count
+		end
+
+		return canCraft
+	end
+
+	return sumItems(inRecipe, { }, math.ceil(count / inRecipe.count))
+end
+
+function Craft.canCraft(item, count, items)
+	return Craft.getCraftableAmount(Craft.recipes[item], count, items) == count
+end
+
+function Craft.setRecipes(recipes)
+	Craft.recipes = recipes
+end
+
+function Craft.getCraftableAmountTest()
+	local results = { }
+	Craft.setRecipes(Util.readTable('usr/etc/recipes.db'))
+
+	local items = {
+		{ name = 'minecraft:planks', damage = 0, count = 5 },
+		{ name = 'minecraft:log',    damage = 0, count = 2 },
+	}
+	results[1] = { item = 'chest', expected = 1,
+		got = Craft.getCraftableAmount(Craft.recipes['minecraft:chest:0'], 2, items) }
+
+	items = {
+		{ name = 'minecraft:log',    damage = 0, count = 1 },
+		{ name = 'minecraft:coal',   damage = 1, count = 1 },
+	}
+	results[2] = { item = 'torch', expected = 4,
+		got = Craft.getCraftableAmount(Craft.recipes['minecraft:torch:0'], 4, items) }
+
+	return results
+end
+
+function Craft.craftRecipeTest(name, count)
+	local ChestAdapter = require('chestAdapter18')
+	local chestAdapter = ChestAdapter({ wrapSide = 'top', direction = 'down' })
+	Craft.setRecipes(Util.readTable('usr/etc/recipes.db'))
+	return { Craft.craftRecipe(Craft.recipes[name], count, chestAdapter) }
+end
+
+Craft.loadRecipes()
+
+return Craft

inventoryManager/apis/inventoryAdapter.lua

@@ -0,0 +1,55 @@
+local Adapter = { }
+
+function Adapter.wrap(args)
+	local adapters = {
+	  'networkedAdapter18',
+		'refinedAdapter',
+		'meAdapter18',
+    'chestAdapter18',
+
+    -- adapters for version 1.7
+    'meAdapter',
+    'chestAdapter',
+  }
+
+  for _,adapterType in ipairs(adapters) do
+		local adapter = require(adapterType)(args)
+
+		if adapter:isValid() then
+
+			-- figure out which direction to push/pull items from an inventory
+			-- based on the side the inventory is attached and which way the
+			-- turtle/computer is facing
+			if args and args.facing and adapter.side and not adapter.direction then
+				local horz = { top = 'down', bottom = 'up' }
+				adapter.direction = horz[adapter.side]
+
+				if not adapter.direction then
+					local sides = {
+						front = 0,
+						right = 1,
+						back = 2,
+						left = 3,
+					}
+		-- pretty sure computer/turtle have sides reversed
+					local cards = {
+						east = 0,
+						south = 1,
+						west = 2,
+						north = 3,
+					}
+					local icards = {
+						[ 0 ] = 'west',
+						[ 1 ] = 'north',
+						[ 2 ] = 'east',
+						[ 3 ] = 'south',
+					}
+					adapter.direction = icards[(cards[args.facing] + sides[adapter.side]) % 4]
+				end
+			end
+			return adapter
+		end
+	end
+end
+
+return Adapter

inventoryManager/apis/networkedAdapter18.lua

@@ -0,0 +1,145 @@
+local class      = require('class')
+local Util       = require('util')
+local InventoryAdapter  = require('inventoryAdapter')
+local itemDB     = require('itemDB')
+local Peripheral = require('peripheral')
+
+local NetworkedAdapter = class()
+
+function NetworkedAdapter:init(args)
+  local defaults = {
+    name = 'Networked Adapter',
+    remotes = { },
+  }
+  Util.merge(self, defaults)
+  Util.merge(self, args)
+
+  if not self.side or self.side == 'network' then
+    self.chests = { }
+    self.modem = Peripheral.get('wired_modem')
+
+    if self.modem and self.modem.getNameLocal then
+      self.localName = self.modem.getNameLocal()
+      for _, v in pairs(self.modem.getNamesRemote()) do
+        local remote = Peripheral.get({ name = v })
+        if remote and remote.size and remote.size() >= 27 and remote.list then
+
+          local adapter = InventoryAdapter.wrap({ side = v, direction = self.localName })
+          if adapter then
+            table.insert(self.remotes, adapter)
+          end
+        end
+      end
+    end
+  end
+
+  _G._p = self
+end
+
+function NetworkedAdapter:isValid()
+  return #self.remotes > 0
+end
+
+function NetworkedAdapter:refresh(throttle)
+  return self:listItems(throttle)
+end
+
+-- provide a consolidated list of items
+function NetworkedAdapter:listItems(throttle)
+  local cache = { }
+  local items = { }
+  throttle = throttle or Util.throttle()
+
+  for _, v in pairs(self.remotes) do
+    v.__cache = v:listItems(throttle)
+
+    for k,v in pairs(v.__cache) do
+      if v.count > 0 then
+        local key = table.concat({ v.name, v.damage, v.nbtHash }, ':')
+
+        local entry = cache[key]
+        if not entry then
+          entry = Util.shallowCopy(v)
+          entry.count = v.count
+          cache[key] = entry
+          table.insert(items, entry)
+        else
+          entry.count = entry.count + v.count
+        end
+
+        throttle()
+      end
+    end
+  end
+
+  if not Util.empty(items) then
+    self.cache = cache
+    return items
+  end
+end
+
+function NetworkedAdapter:getItemInfo(item)
+  if not self.cache then
+    self:listItems()
+  end
+  local key = table.concat({ item.name, item.damage, item.nbtHash }, ':')
+  local items = self.cache or { }
+  return items[key]
+end
+
+function NetworkedAdapter:getPercentUsed()
+  if self.cache and self.getDrawerCount then
+    return math.floor(Util.size(self.cache) / self.getDrawerCount() * 100)
+  end
+  return 0
+end
+
+function NetworkedAdapter:provide(item, qty, slot, direction)
+  local total = 0
+
+  for _, remote in pairs(self.remotes) do
+debug('%s -> slot %d: %d %s', remote.side, slot, qty, item.name)
+    local amount = remote:provide(item, qty, slot)
+    qty = qty - amount
+    total = total + amount
+    if qty <= 0 then
+      break
+    end
+  end
+
+  return total
+end
+
+function NetworkedAdapter:extract(slot, qty, toSlot)
+
+  error('extract not supported')
+  local total = 0
+  for _, remote in pairs(self.remotes) do
+debug('extract %d slot:%d', qty, slot)
+    local amount = remote:extract(slot, qty, toSlot)
+    qty = qty - amount
+    total = total + amount
+    if qty <= 0 then
+      break
+    end
+  end
+
+  return total
+end
+
+function NetworkedAdapter:insert(slot, qty, toSlot)
+  local total = 0
+  for _, remote in pairs(self.remotes) do
+debug('slot %d -> %s: %s', slot, remote.side, qty)
+    local amount = remote:insert(slot, qty, toSlot)
+    qty = qty - amount
+    total = total + amount
+    if qty <= 0 then
+      break
+    end
+  end
+
+  return total
+end
+
+return NetworkedAdapter