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.
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érique | mod |
|---|---|---|
| Contrôleur ME | me_controller | Applied Energistics 2 |
| Interface ME, le bloc ou la part posée sur un câble | me_interface | Applied Energistics 2 |
| Contrôleur, Contrôleur créatif | rs_controller | Refined Storage |
| Interface | rs_interface | Refined Storage |
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 gaucheme.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 :
| erreur | quand |
|---|---|
ME controller removed | le bloc a été cassé ou remplacé depuis peripheral.wrap : de même ME interface removed, controller removed, interface removed |
peripheral is not loaded | le 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()
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.
- boolean
- vrai tant que le réseau fonctionne
local me = peripheral.find("me_controller")
while not me.online() do
print("En attente du réseau ME...")
sleep(5)
endVoir 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.
patternstring facultatif- les objets à lister, un id avec * et ? permis ; tous les objets sans lui
- table
- une liste de {name, count, display}, les plus nombreux d'abord
for _, it in ipairs(me.items("*_ingot")) do
print(it.count, it.display)
endVoir 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).
patternstring facultatif- les fluides à lister, un id avec * et ? permis ; tous les fluides sans lui
- table
- une liste de {name, amount, display}, amount en mB, les plus gros d'abord
for _, f in ipairs(me.fluids()) do
print(f.amount / 1000 .. " seaux de " .. f.display)
endVoir aussi storage_network.amount() storage_network.items()
me.count([pattern])
Combien d'objets le motif nomme, toutes sortes confondues.
patternstring facultatif- les objets à compter, un id avec * et ? permis ; tous les objets sans lui
- number
- combien le réseau en contient
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.
patternstring facultatif- les fluides à mesurer, un id avec * et ? permis ; tous les fluides sans lui
- number
- combien de mB le réseau en contient
print(me.amount("minecraft:lava") / 1000 .. " seaux de lave")Voir aussi storage_network.fluids() storage_network.count()
À 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}.
- table
- {items = {used, total}, fluids = {used, total}}
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")
endVoir aussi storage_network.count()
Entrer et sortir objets et fluides
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.
targetstring- le nom d'un inventaire de l'ordinateur ("left", "inventory@12,64,-30"...)
itemstring- les objets à déplacer, un id avec * et ? permis
countnumber facultatif- combien au plus, 64 par défaut
- number
- combien d'objets ont bougé
-- 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.
sourcestring- le nom d'un inventaire de l'ordinateur
slotnumber facultatif- le seul emplacement où prendre, à partir de 1 ; tous les emplacements sans lui
countnumber facultatif- combien au plus, 64 par défaut
- number
- combien d'objets ont bougé
-- vide le coffre de gauche dans le réseau
while me.pull("left") > 0 do endVoir 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.
targetstring- le nom d'un réservoir de l'ordinateur
fluidstring- les fluides à déplacer, un id avec * et ? permis
amountnumber facultatif- combien de mB au plus, 1000 par défaut
- number
- combien de mB ont bougé
me.push_fluid("back", "minecraft:water", 4000) -- 4 seauxVoir aussi storage_network.pull_fluid() tank.tanks()
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.
sourcestring- le nom d'un réservoir de l'ordinateur
amountnumber facultatif- combien de mB au plus, 1000 par défaut
- number
- combien de mB ont bougé
local moved = me.pull_fluid("bottom", 8000)
print(moved .. " mB rangés")Voir aussi storage_network.push_fluid()
Énergie
me.power()
L'énergie que le réseau garde dans son contrôleur et ses cellules d'énergie.
- number
- l'énergie stockée, en AE (AE2) ou en FE (Refined Storage)
print(me.power() .. " / " .. me.power_capacity())Voir aussi storage_network.power_capacity() storage_network.power_usage()
me.power_capacity()
- number
- l'énergie que le réseau stocke au plus
local part = me.power() / me.power_capacity()
print(math.floor(part * 100) .. " % chargé")Voir aussi storage_network.power()
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.
- number
- l'énergie que le réseau consomme par tick
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.
patternstring facultatif- les objets à lister, un id avec * et ? permis ; tous les objets sans lui
- table
- une liste de {name, display}, par id
for _, it in ipairs(me.craftable()) do
print(it.display)
endVoir aussi storage_network.craft()
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 :
itemstring- l'id de l'objet à fabriquer
countnumber facultatif- combien, 1 par défaut, jusqu'à 1048576
- table
- {ok = true} une fois la fabrication lancée, sinon {ok = false, error, missing}
| error | pourquoi |
|---|---|
offline | le réseau est hors ligne |
not_craftable | aucun patron ne fabrique cet objet |
missing_resources | les ingrédients ne sont pas tous là : missing liste ce qui manque, {name, count, display} chacun |
no_cpu | AE2 : le réseau n'a aucun processeur de fabrication en marche |
cpu_busy | AE2 : tous les processeurs de fabrication assez grands sont occupés |
cpu_too_small | AE2 : aucun processeur de fabrication n'a assez d'octets pour ce travail |
cycle | Refined Storage : les patrons se fabriquent l'un l'autre en boucle |
too_many | Refined Storage : les quantités sont trop grandes pour faire un plan |
timed_out | le plan a pris plus de 20 secondes |
failed | le mod a refusé le travail pour une autre raison |
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)
endVoir aussi storage_network.crafting() storage_network.cancel() storage_network.cpus()
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.
- table
- une liste de {name, count, progress, display}, progress de 0 à 1
for _, job in ipairs(me.crafting()) do
print(job.display .. " : " .. math.floor(job.progress * 100) .. " %")
endVoir aussi storage_network.craft() storage_network.cancel()
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.
itemstring- les objets dont arrêter la fabrication, un id avec * et ? permis
- number
- combien de fabrications ont été arrêtées
me.cancel("minecraft:piston")Voir aussi storage_network.crafting()
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.
- table
- une liste de {name, busy, storage, coprocessors}
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.
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)
endExemple : 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.
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