Create logistics

Packs the inventory behind the Packager now, like a redstone pulse would. If the computer gave an address with set_address, the package gets it.

local packager = peripheral.find("packager")
packager.set_address("Smeltery")
if packager.make_package() then
  print("a package leaves for the Smeltery")
end

It returns false, and packs nothing, when:

• the Packager still holds the previous package (a belt, a chute or a Frogport must take it away first);
• the inventory behind it is empty, or missing;
• it made a package less than two seconds ago, as with a button;
• a Stock Link is on it: it then works for its logistics network only.

See also packager.set_address() packager.package()

What the Packager would pack: the items of the inventory behind it, read like inventory.list().

Without an inventory behind it, the program stops with the packager has no inventory behind it.

See also packager.get() inventory.list()

One slot of the inventory behind the Packager. A slot outside the inventory stops the program with bad argument #1 to 'get' (slot 30 out of range, 1 to 27).

See also packager.list()

The address the packages made by make_package will get.

See also packager.set_address()

Sets the address of the packages this computer makes with make_package. It does not change the sign, nor the address of the packages the Packager makes on its own.

See also packager.address() packager.make_package()

The package the Packager holds right now: one it just made, before it leaves.

order holds id (the number of the order), index (the place of this package among those this Packager makes for the order, from 1), final (true for its last one), link_index and final_link (the same, among the Packagers of the network that share the order), and items, every item of the order.

A package only stays a moment: ask often (every 0.1 second) to see each one.

local packager = peripheral.find("packager")
local box = packager.package()
if box then
  print("to " .. box.address .. ": " .. #box.items .. " stacks")
end

See also packager.set_package_address()

Changes the address of the package the Packager holds, before it leaves. When it holds none, the program stops with the packager holds no package.

A Packager that empties a mine's chest, and sends what has no address to the warehouse:

local packager = peripheral.find("packager")
while true do
  local box = packager.package()
  if box and box.address == "" then
    packager.set_package_address("Warehouse")
  end
  sleep(0.1)
end

See also packager.package()

The address the port catches packages for. Create allows * in it ("Kitchen*"), and an empty address catches the packages that have none.

See also package_port.set_address()

Changes the address the port catches packages for, as its screen does.

See also package_port.address()

What the port does:

• "send_receive": it catches the packages for its address, and sends the others on;
• "send": it only sends the packages put into it, and catches nothing;
• nil: it is not linked yet to a Chain Conveyor or a Train Station.

See also package_port.set_configuration()

Chooses what the port does. Another word stops the program; "send_recieve", the spelling of Create's ComputerCraft peripheral, works too.

See also package_port.configuration()

The packages waiting in the port, read like inventory.list().

local port = peripheral.find("postbox")
local known = 0
while true do
  local count = 0
  for _, stack in pairs(port.list()) do
    count = count + stack.count
  end
  if count > known then
    print("You have mail: " .. count .. " package(s)")
  end
  known = count
  sleep(5)
end

See also package_port.get()

One slot of the port. A slot outside it stops the program, as with packager.get().

See also package_port.list()

Sends the order now, like a redstone pulse. Once per tick at most: a second call in the same tick fails and says to wait (sleep(0)).

In "strict" mode nothing leaves unless every item is in stock; in "allow_partial" mode, what there is leaves.

See also redstone_requester.set_request() redstone_requester.set_configuration()

Replaces the order. An id alone asks for one item.

local req = peripheral.find("redstone_requester")
req.set_request("minecraft:bread", {name = "minecraft:coal", count = 32})

More than 9 items stops the program with too many items for 'set_request' (9 at most), a count out of range with bad argument #2 to 'set_request' (count 1 to 256).

See also redstone_requester.get_request() redstone_requester.request()

Orders ingredients together with their recipe, for an automatic crafting line.

The items are sent like with set_request, the recipe attached: at the other end, a Re-Packager makes one package per craft, and a Packager unpacking them into Mechanical Crafters lays each item on its square. The count of an item is how many of it the order asks for, so give each square as many items as there are crafts:

local req = peripheral.find("redstone_requester")
local plank = {name = "minecraft:oak_planks", count = 4}
-- 4 crafting tables: planks on the first two squares of the first two rows
req.set_crafting_request(4, plank, plank, nil, plank, plank)

See also redstone_requester.set_request()

The order the requester sends, indexed by square as it was set: a crafting pattern keeps its holes, so set_crafting_request(1, "oak_planks", nil, "stick") reads back with a square 1 and a square 3, and no square 2. Go through it with pairs, which skips the holes.

local req = peripheral.find("redstone_requester")
for square, item in pairs(req.get_request()) do
  print(square .. ": " .. item.count .. " x " .. item.display)
end

See also redstone_requester.set_request()

Whether the requester sends what there is ("allow_partial") or waits until everything is in stock ("strict").

See also redstone_requester.set_configuration()

Chooses the mode. Another word stops the program.

See also redstone_requester.configuration()

Where the packages of the order go.

See also redstone_requester.set_address()

Changes where the packages of the order go.

Keeping the furnaces fed: the coal chest on the left of the computer never runs low.

local req = peripheral.find("redstone_requester")
local chest = peripheral.wrap("left")
req.set_request({name = "minecraft:coal", count = 64})
req.set_address("Furnaces")
req.set_configuration("allow_partial")
while true do
  if chest.count("minecraft:coal") < 32 then
    req.request()
    sleep(30)  -- the time for the package to arrive
  end
  sleep(5)
end

See also redstone_requester.address()

The whole stock of the network. count is the total of that item in all the inventories, often far more than 64.

local ticker = peripheral.find("stock_ticker")
for _, entry in ipairs(ticker.stock()) do
  print(entry.count .. " x " .. entry.display)
end

See also stock_ticker.stock_item() stock_ticker.request()

One entry of the stock, without building the whole list. The order of the list changes when the stock changes.

See also stock_ticker.stock()

Sends items of the network to an address, in packages. Once per tick at most, since the stock it reads is counted once per tick: a second call in the same tick fails and says to wait (sleep(0)).

Each filter picks items of the stock:

• name is compared with the complete id: "minecraft:iron_ingot". * stands for any text and ? for one character: "minecraft:*_log" takes every kind of log, "create:*" everything from Create. A plain name without : is a Minecraft item, as everywhere else: "iron_ingot" is "minecraft:iron_ingot". A pattern is compared with the whole id: "*_ingot" takes the ingots of every mod.
• count is the most to take, over all the items the name matches, in the order of stock(). Without it, the filter takes all of them.
• The filters take one after the other: a second filter only finds what the first one left.

local ticker = peripheral.find("stock_ticker")
local n = ticker.request("Workshop",
  {name = "minecraft:iron_ingot", count = 64},
  {name = "minecraft:*_log", count = 128},
  {name = "create:andesite_alloy"})
print(n .. " items on their way to the Workshop")

It returns how many items were asked for. They leave from the Packagers of the network, so they arrive a while later, in several packages. A filter that is not a table with a name stops the program with bad argument #3 to 'request' ({name = id, count = n} expected).

See also stock_ticker.stock()

The payments the Stock Ticker received from the shops of its network, read like inventory.list().

See also stock_ticker.get()

One payment slot. A slot outside them stops the program, as with packager.get().

See also stock_ticker.list()

Whether the cloth sells something. All the other methods, except set_wares, need a shop: on a plain cloth, they stop the program with this table cloth is not a shop.

See also table_cloth.set_wares()

The wares of the shop.

local shop = peripheral.find("table_cloth")
for _, ware in ipairs(shop.wares()) do
  print(ware.count .. " x " .. ware.display)
end

See also table_cloth.set_wares()

Sets what one purchase gives, and makes the cloth a shop. Called with nothing, it turns the shop back into a plain cloth.

local shop = peripheral.find("table_cloth")
shop.set_wares({name = "minecraft:bread", count = 8}, "minecraft:cake")

Items lying on the cloth, put there by a player, stop the program with the table cloth holds items: take them off first.

See also table_cloth.wares() table_cloth.shop()

The payment item. Its count is 1: the price itself is price_count().

See also table_cloth.set_price_item() table_cloth.price_count()

Sets the item asked as payment. A shop without a price item refuses to sell.

See also table_cloth.price_item()

The price, in payment items.

See also table_cloth.set_price_count()

Sets the price, in payment items.

See also table_cloth.price_count()

The address of the packages of goods: usually a Frogport or a Postbox at the shop counter.

See also table_cloth.set_address()

Changes where the shop sends what it sells.

A bakery whose price follows the stock: bread is dearer when little is left.

local shop = peripheral.find("table_cloth")
local ticker = peripheral.find("stock_ticker")
shop.set_price_item("minecraft:emerald")
while true do
  local bread = 0
  for _, entry in ipairs(ticker.stock()) do
    if entry.name == "minecraft:bread" then
      bread = entry.count
    end
  end
  if bread < 64 then
    shop.set_price_count(3)
  else
    shop.set_price_count(1)
  end
  sleep(30)
end

See also table_cloth.address()