Create: Computing AgesDoc Brass
Périphériques

Réseaux de stockage (AE2, Refined Storage)

Les réseaux de stockage d'Applied Energistics 2 et de Refined Storage, par leurs contrôleurs et leurs interfaces : ce qu'ils contiennent, objets et fluides entrés et sortis, leur stockage et leur énergie, et la fabrication avec leurs patrons.

Il faut Applied Energistics 2 ou Refined Storage

Les blocs de cette page viennent d'Applied Energistics 2 (AE2) et de Refined Storage. Sans ces mods, ils n'existent pas, et peripheral.find("me_controller") renvoie nil.

AE2 et Refined Storage rangent des milliers d'objets dans un seul réseau de lecteurs et de disques, et fabriquent ce qui manque avec leurs patrons. Un ordinateur relié au contrôleur du réseau ou à l'une de ses interfaces voit tout : il compte n'importe quel objet, sort des objets et des fluides vers un coffre ou un réservoir, range ce que contient un coffre, surveille le stockage et l'énergie, et demande au réseau de fabriquer. Le même programme marche avec les deux mods.

Bloc (en jeu)type de périphériquemod
Contrôleur MEme_controllerApplied Energistics 2
Interface ME, le bloc ou la part posée sur un câbleme_interfaceApplied Energistics 2
Contrôleur, Contrôleur créatifrs_controllerRefined Storage
Interfacers_interfaceRefined Storage
Brass
local me = peripheral.find("me_controller")
print(me.count("minecraft:iron_ingot") .. " lingots de fer")
me.push("left", "minecraft:iron_ingot", 16)  -- 16 d'entre eux dans le coffre de gauche
Méthodes
me.online()true tant que le réseau a de l'énergie et que le bloc fonctionne : pour une Interface ME, qu'elle a aussi son canal ; pour Refined Storage, que son mode redstone le permet. Hors ligne, toutes les autres méthodes voient un réseau vide.
me.items([pattern])Les objets que contient le réseau, une entrée par sorte : name son id, count combien, display son nom en jeu. Les plus gros stocks viennent d'abord.
me.fluids([pattern])Les fluides que contient le réseau, comme storage_network.items() : amount est en mB (1000 pour un seau).
me.count([pattern])Combien d'objets le motif nomme, toutes sortes confondues.
me.amount([pattern])Combien de fluide le motif nomme, en mB.
me.storage()À quel point le stockage est plein. AE2 compte les octets des cellules de ses range-disques et coffres ME (une cellule 1k a 1024 octets, et chaque sorte d'objet en prend aussi), Refined Storage les objets et les mB de ses disques et blocs de stockage. Le stockage que le réseau atteint par un bus de stockage ou un stockage externe, et le stockage créatif sans limite, ne sont pas comptés. Sans stockage de fluides, fluids vaut {used = 0, total = 0}.
me.push(target, item [, count])Sort des objets du réseau vers un inventaire : un coffre, une machine, un dépôt de Create. Il s'arrête quand count objets ont bougé, que la cible est pleine ou que le réseau n'en a plus. Les objets que la cible refuse au dernier moment retournent dans le réseau, ou par terre, jamais perdus.
me.pull(source [, slot [, count]])Range les objets d'un inventaire dans le réseau, comme un bus d'import. Ce pour quoi le réseau n'a pas de place reste dans l'inventaire.
me.push_fluid(target, fluid [, amount])Sort du fluide du réseau vers un réservoir : un réservoir à fluide de Create, un bassin, une chaudière.
me.pull_fluid(source [, amount])Range le fluide d'un réservoir dans le réseau : le fluide que le réservoir donne en premier, comme un tuyau le prendrait.
me.power()L'énergie que le réseau garde dans son contrôleur et ses cellules d'énergie.
me.power_capacity()lua local part = me.power() / me.power_capacity() print(math.floor(part * 100) .. " % chargé")
me.power_usage()Ce que le réseau consomme par tick (20 ticks par seconde) : avec AE2, sa moyenne sur les dernières secondes ; avec Refined Storage, ce que tirent ses blocs en marche.
me.craftable([pattern])Les objets pour lesquels le réseau a un patron : avec AE2, dans ses fournisseurs de patterns ; avec Refined Storage, dans ses artisans automatiques.
me.craft(item [, count])Demande au réseau de fabriquer, comme un joueur dans un terminal de fabrication. Le mod prépare d'abord le plan, ce qui prend quelques ticks : le programme attend le plan (20 secondes au plus), puis la fabrication démarre et craft renvoie {ok = true}, pendant que la fabrication elle-même continue. Quand elle ne peut pas démarrer, ok vaut false et error dit pourquoi :
me.crafting()Les fabrications en cours : ce que chacune fabrique, combien en tout, et où elle en est (de 0 à 1). Une fabrication quitte la liste une fois ses objets rangés dans le réseau.
me.cancel(item)Arrête toutes les fabrications de ce que le motif nomme, comme le bouton d'annulation d'un écran de fabrication. Les ingrédients qu'une fabrication avait pris retournent dans le réseau.
me.cpus()AE2 seulement : les processeurs de fabrication du réseau. name est le nom donné au processeur en jeu (sinon "CPU 1", "CPU 2"...), busy s'il fait tourner une fabrication, storage ses octets, coprocessors combien d'unités de coprocesseur il a. Une fabrication tourne sur un processeur libre qui a assez d'octets. Refined Storage n'a pas de processeurs : ses interfaces et contrôleurs n'ont pas de méthode cpus.

Installation

L'atteindre. Posez le bloc contre une face de l'ordinateur (peripheral.wrap("left")), ou contre un câble de données du réseau de l'ordinateur, à partir du Mini-ordinateur : il est alors nommé comme me_controller@120,64,-35. Le plus simple est peripheral.find avec le type du tableau ci-dessus. Une part Interface ME compte quand elle est sur la face de son câble tournée vers l'ordinateur (ou vers le câble de données) : un câble qui porte une interface sur une autre face n'est pas un périphérique. Voir Périphériques.

Les mêmes méthodes pour les deux mods. Les quatre types ont les mêmes méthodes, documentées une seule fois ci-dessous sous le nom storage_network ; seule storage_network.cpus() est propre à AE2. Ce qui change, ce sont les règles de chaque mod : AE2 compte son stockage en octets et son énergie en AE, Refined Storage en objets, en mB et en FE. Un programme écrit pour un réseau tourne sur l'autre en changeant le type qu'il cherche.

Nommer objets et fluides. Un objet ou un fluide se nomme par son id, comme partout en Brass : "minecraft:iron_ingot", "minecraft:water" ; un nom seul est celui de Minecraft ("iron_ingot"). Là où une méthode prend un motif, * remplace n'importe quel texte et ? un caractère : "*_ingot" nomme tous les lingots, "create:*" tous les objets de Create. Des objets de même id mais avec des données à eux (un livre enchanté, un outil abîmé, un sac à dos rempli) sont listés à part, chacun avec son nom display ; un motif les nomme tous.

En ligne ou non. Un réseau fonctionne tant qu'il a de l'énergie : AE2 demande aussi un canal pour l'Interface ME (un réseau sans contrôleur en a 8), Refined Storage demande que son contrôleur soit alimenté et que le mode redstone du bloc le permette. storage_network.online() le dit. Hors ligne, un réseau ne contient rien pour l'ordinateur, comme ses terminaux le montrent : les listes sont vides, les comptes à 0, rien ne bouge, et storage_network.craft() répond {ok = false, error = "offline"}.

Ce que ça coûte. L'ordinateur agit comme une machine du réseau. Avec AE2, chaque objet ou mB déplacé coûte de l'énergie AE, comme pour un bus d'import ou d'export. Une méthode qui lit tout le réseau (listes, comptes, push) coûte au programme une instruction par sorte d'objet ou de fluide stockée : sur un réseau de 5 000 sortes, appelez-la une fois et gardez le résultat plutôt que dans chaque boucle.

Quand le réseau change. Refined Storage montre un changement tout de suite. AE2 rafraîchit sa liste une fois par tick : ce que l'ordinateur déplace lui-même se voit tout de suite, mais ce qu'une autre machine a déplacé dans le même tick n'apparaît qu'au suivant, comme dans les terminaux d'AE2.

Des blocs qui font autre chose aussi. L'Interface ME et l'Interface de Refined Storage gardent des objets à elles : ce sont aussi des inventaires, et un bloc qui contient de la Forge Energy est aussi un bloc Blocs d'énergie. Les méthodes du réseau passent en premier : sur une interface, count() et push() agissent sur tout le réseau, tandis que list(), get() et size() lisent les emplacements de l'interface elle-même.

Chaque appel relit le bloc, si bien qu'un bloc enveloppé ne devient jamais périmé. Quand quelque chose ne va pas, l'appel arrête le programme avec une erreur que l'on peut rattraper avec pcall :

erreurquand
ME controller removedle bloc a été cassé ou remplacé depuis peripheral.wrap : de même ME interface removed, controller removed, interface removed
peripheral is not loadedle tronçon (chunk) du bloc n'est pas chargé
no inventory 'left', no tank 'left'push, pull, push_fluid ou pull_fluid a reçu un nom qui n'est pas un inventaire (un réservoir) de l'ordinateur
bad argument #1 to 'craft' (...)un mauvais argument : le message dit ce qui était attendu
this version of Applied Energistics 2 has no ...votre version du mod n'a pas ce que la méthode lit (de même Refined Storage)
Applied Energistics 2 error: ...le mod lui-même a échoué en répondant (de même Refined Storage error: ...)

Ce qu'il contient

#

me.online()

→ boolean

true tant que le réseau a de l'énergie et que le bloc fonctionne : pour une Interface ME, qu'elle a aussi son canal ; pour Refined Storage, que son mode redstone le permet. Hors ligne, toutes les autres méthodes voient un réseau vide.

Renvoie
boolean
vrai tant que le réseau fonctionne
Brass
local me = peripheral.find("me_controller")
while not me.online() do
  print("En attente du réseau ME...")
  sleep(5)
end

Voir aussi storage_network.power()

#

me.items([pattern])

Les objets que contient le réseau, une entrée par sorte : name son id, count combien, display son nom en jeu. Les plus gros stocks viennent d'abord.

Paramètres
pattern string facultatif
les objets à lister, un id avec * et ? permis ; tous les objets sans lui
Renvoie
table
une liste de {name, count, display}, les plus nombreux d'abord
Brass
for _, it in ipairs(me.items("*_ingot")) do
  print(it.count, it.display)
end

Voir aussi storage_network.count() storage_network.fluids()

#

me.fluids([pattern])

Les fluides que contient le réseau, comme storage_network.items() : amount est en mB (1000 pour un seau).

Paramètres
pattern string facultatif
les fluides à lister, un id avec * et ? permis ; tous les fluides sans lui
Renvoie
table
une liste de {name, amount, display}, amount en mB, les plus gros d'abord
Brass
for _, f in ipairs(me.fluids()) do
  print(f.amount / 1000 .. " seaux de " .. f.display)
end

Voir aussi storage_network.amount() storage_network.items()

#

me.count([pattern])

Combien d'objets le motif nomme, toutes sortes confondues.

Paramètres
pattern string facultatif
les objets à compter, un id avec * et ? permis ; tous les objets sans lui
Renvoie
number
combien le réseau en contient
Brass
if me.count("minecraft:coal") < 64 then
  print("Plus beaucoup de charbon")
end
print(me.count() .. " objets en tout")

Voir aussi storage_network.items() storage_network.amount()

#

me.amount([pattern])

Combien de fluide le motif nomme, en mB.

Paramètres
pattern string facultatif
les fluides à mesurer, un id avec * et ? permis ; tous les fluides sans lui
Renvoie
number
combien de mB le réseau en contient
Brass
print(me.amount("minecraft:lava") / 1000 .. " seaux de lave")

Voir aussi storage_network.fluids() storage_network.count()

#

me.storage()

→ table⚙ coût 8

À quel point le stockage est plein. AE2 compte les octets des cellules de ses range-disques et coffres ME (une cellule 1k a 1024 octets, et chaque sorte d'objet en prend aussi), Refined Storage les objets et les mB de ses disques et blocs de stockage. Le stockage que le réseau atteint par un bus de stockage ou un stockage externe, et le stockage créatif sans limite, ne sont pas comptés. Sans stockage de fluides, fluids vaut {used = 0, total = 0}.

Renvoie
table
{items = {used, total}, fluids = {used, total}}
Brass
local s = me.storage().items
if s.total > 0 and s.used / s.total > 0.9 then
  print("Stockage plein à 90 % : ajoutez un range-disque")
end

Voir aussi storage_network.count()

Entrer et sortir objets et fluides

Sort des objets du réseau vers un inventaire : un coffre, une machine, un dépôt de Create. Il s'arrête quand count objets ont bougé, que la cible est pleine ou que le réseau n'en a plus. Les objets que la cible refuse au dernier moment retournent dans le réseau, ou par terre, jamais perdus.

Paramètres
target string
le nom d'un inventaire de l'ordinateur ("left", "inventory@12,64,-30"...)
item string
les objets à déplacer, un id avec * et ? permis
count number facultatif
combien au plus, 64 par défaut
Renvoie
number
combien d'objets ont bougé
Brass
-- nourrit un four à droite avec 8 minerais de fer
me.push("right", "minecraft:iron_ore", 8)

Voir aussi storage_network.pull() inventory.push()

#

me.pull(source [, slot [, count]])

Range les objets d'un inventaire dans le réseau, comme un bus d'import. Ce pour quoi le réseau n'a pas de place reste dans l'inventaire.

Paramètres
source string
le nom d'un inventaire de l'ordinateur
slot number facultatif
le seul emplacement où prendre, à partir de 1 ; tous les emplacements sans lui
count number facultatif
combien au plus, 64 par défaut
Renvoie
number
combien d'objets ont bougé
Brass
-- vide le coffre de gauche dans le réseau
while me.pull("left") > 0 do end

Voir aussi storage_network.push() inventory.push()

#

me.push_fluid(target, fluid [, amount])

Sort du fluide du réseau vers un réservoir : un réservoir à fluide de Create, un bassin, une chaudière.

Paramètres
target string
le nom d'un réservoir de l'ordinateur
fluid string
les fluides à déplacer, un id avec * et ? permis
amount number facultatif
combien de mB au plus, 1000 par défaut
Renvoie
number
combien de mB ont bougé
Brass
me.push_fluid("back", "minecraft:water", 4000) -- 4 seaux

Voir aussi storage_network.pull_fluid() tank.tanks()

#

me.pull_fluid(source [, amount])

→ number

Range le fluide d'un réservoir dans le réseau : le fluide que le réservoir donne en premier, comme un tuyau le prendrait.

Paramètres
source string
le nom d'un réservoir de l'ordinateur
amount number facultatif
combien de mB au plus, 1000 par défaut
Renvoie
number
combien de mB ont bougé
Brass
local moved = me.pull_fluid("bottom", 8000)
print(moved .. " mB rangés")

Voir aussi storage_network.push_fluid()

Énergie

#

me.power()

→ number

L'énergie que le réseau garde dans son contrôleur et ses cellules d'énergie.

Renvoie
number
l'énergie stockée, en AE (AE2) ou en FE (Refined Storage)
Brass
print(me.power() .. " / " .. me.power_capacity())

Voir aussi storage_network.power_capacity() storage_network.power_usage()

#

me.power_capacity()

→ number
Renvoie
number
l'énergie que le réseau stocke au plus
Brass
local part = me.power() / me.power_capacity()
print(math.floor(part * 100) .. " % chargé")

Voir aussi storage_network.power()

#

me.power_usage()

→ number

Ce que le réseau consomme par tick (20 ticks par seconde) : avec AE2, sa moyenne sur les dernières secondes ; avec Refined Storage, ce que tirent ses blocs en marche.

Renvoie
number
l'énergie que le réseau consomme par tick
Brass
local ticks = me.power() / math.max(me.power_usage(), 1)
print("Énergie pour " .. math.floor(ticks / 20 / 60) .. " minutes")

Voir aussi storage_network.power()

Fabrication

#

me.craftable([pattern])

Les objets pour lesquels le réseau a un patron : avec AE2, dans ses fournisseurs de patterns ; avec Refined Storage, dans ses artisans automatiques.

Paramètres
pattern string facultatif
les objets à lister, un id avec * et ? permis ; tous les objets sans lui
Renvoie
table
une liste de {name, display}, par id
Brass
for _, it in ipairs(me.craftable()) do
  print(it.display)
end

Voir aussi storage_network.craft()

#

me.craft(item [, count])

→ table⏸ Attend⚙ coût 32

Demande au réseau de fabriquer, comme un joueur dans un terminal de fabrication. Le mod prépare d'abord le plan, ce qui prend quelques ticks : le programme attend le plan (20 secondes au plus), puis la fabrication démarre et craft renvoie {ok = true}, pendant que la fabrication elle-même continue. Quand elle ne peut pas démarrer, ok vaut false et error dit pourquoi :

Paramètres
item string
l'id de l'objet à fabriquer
count number facultatif
combien, 1 par défaut, jusqu'à 1048576
Renvoie
table
{ok = true} une fois la fabrication lancée, sinon {ok = false, error, missing}
errorpourquoi
offlinele réseau est hors ligne
not_craftableaucun patron ne fabrique cet objet
missing_resourcesles ingrédients ne sont pas tous là : missing liste ce qui manque, {name, count, display} chacun
no_cpuAE2 : le réseau n'a aucun processeur de fabrication en marche
cpu_busyAE2 : tous les processeurs de fabrication assez grands sont occupés
cpu_too_smallAE2 : aucun processeur de fabrication n'a assez d'octets pour ce travail
cycleRefined Storage : les patrons se fabriquent l'un l'autre en boucle
too_manyRefined Storage : les quantités sont trop grandes pour faire un plan
timed_outle plan a pris plus de 20 secondes
failedle mod a refusé le travail pour une autre raison
Brass
local r = me.craft("minecraft:piston", 16)
if r.ok then
  print("Fabrication de 16 pistons")
elseif r.error == "missing_resources" then
  for _, it in ipairs(r.missing) do
    print("Il manque " .. it.count .. " " .. it.display)
  end
else
  print("Impossible de fabriquer : " .. r.error)
end

Voir aussi storage_network.crafting() storage_network.cancel() storage_network.cpus()

#

me.crafting()

→ table

Les fabrications en cours : ce que chacune fabrique, combien en tout, et où elle en est (de 0 à 1). Une fabrication quitte la liste une fois ses objets rangés dans le réseau.

Renvoie
table
une liste de {name, count, progress, display}, progress de 0 à 1
Brass
for _, job in ipairs(me.crafting()) do
  print(job.display .. " : " .. math.floor(job.progress * 100) .. " %")
end

Voir aussi storage_network.craft() storage_network.cancel()

#

me.cancel(item)

→ number

Arrête toutes les fabrications de ce que le motif nomme, comme le bouton d'annulation d'un écran de fabrication. Les ingrédients qu'une fabrication avait pris retournent dans le réseau.

Paramètres
item string
les objets dont arrêter la fabrication, un id avec * et ? permis
Renvoie
number
combien de fabrications ont été arrêtées
Brass
me.cancel("minecraft:piston")

Voir aussi storage_network.crafting()

#

me.cpus()

→ table

AE2 seulement : les processeurs de fabrication du réseau. name est le nom donné au processeur en jeu (sinon "CPU 1", "CPU 2"...), busy s'il fait tourner une fabrication, storage ses octets, coprocessors combien d'unités de coprocesseur il a. Une fabrication tourne sur un processeur libre qui a assez d'octets. Refined Storage n'a pas de processeurs : ses interfaces et contrôleurs n'ont pas de méthode cpus.

Renvoie
table
une liste de {name, busy, storage, coprocessors}
Brass
local libres = 0
for _, cpu in ipairs(me.cpus()) do
  if not cpu.busy then libres = libres + 1 end
end
print(libres .. " processeur(s) de fabrication libre(s)")

Voir aussi storage_network.craft() storage_network.crafting()

Exemple : garder un stock

Toutes les minutes, l'ordinateur remet une liste d'objets à niveau, en fabriquant ce qui manque : quelques lignes qui remplacent une rangée d'émetteurs de niveau et de cartes de fabrication.

Brass
local me = peripheral.find("me_controller")
local stock = {["minecraft:piston"] = 32, ["minecraft:torch"] = 256, ["create:andesite_alloy"] = 128}
while true do
  for id, voulu in pairs(stock) do
    local a = me.count(id)
    if a < voulu and #me.crafting() < 4 then
      local r = me.craft(id, voulu - a)
      if not r.ok then print(id .. " : " .. r.error) end
    end
  end
  sleep(60)
end

Exemple : un tableau de bord du réseau

Sur l'écran de l'ordinateur (et les moniteurs qui lui sont joints) : le stockage, l'énergie et les fabrications en cours, rafraîchis toutes les 5 secondes.

Brass
local me = peripheral.find("rs_controller")
while true do
  local s = me.storage().items
  local lignes = {
    "Objets : " .. me.count() .. " (plein à " .. math.floor(100 * s.used / math.max(s.total, 1)) .. " %)",
    "Énergie : " .. math.floor(100 * me.power() / math.max(me.power_capacity(), 1)) .. " %",
  }
  for _, job in ipairs(me.crafting()) do
    lignes[#lignes + 1] = job.display .. " x" .. job.count .. " " .. math.floor(job.progress * 100) .. " %"
  end
  term.clear()
  for i, ligne in ipairs(lignes) do
    term.set_cursor(1, i)
    term.write(ligne)
  end
  sleep(5)
end