peripheral

Un périphérique est un bloc avec lequel l'ordinateur peut parler : un coffre, une machine de Create, un Feu tricolore, un moniteur, un capteur de Create Aeronautics. La bibliothèque peripheral trouve ces blocs et donne au programme un objet qui porte les fonctions propres au bloc, ses méthodes : coffre.count(), feu.set("green"), controleur.set_speed(64). Tous les ordinateurs l'ont.

local coffre = peripheral.wrap("left")
print(coffre.count("minecraft:iron_ingot") .. " lingots de fer")

Les blocs contre l'ordinateur portent le nom de la face qu'ils touchent : "front", "back", "left", "right", "top" et "bottom", comme pour rs (gauche et droite vues face à l'écran). Le bloc qui entraîne l'ordinateur compte aussi : l'arbre de l'arrière (du dessous pour un Microcontrôleur) est un périphérique kinetic.

Les blocs du Câble de données. À partir du Mini-ordinateur, chaque bloc qui touche le réseau de Câble de données de l'ordinateur est aussi un périphérique, nommé type@x,y,z : son type et ses coordonnées, telles que F3 les affiche, comme inventory@120,64,-35. Le nom ne change pas tant que le bloc reste là.

• Les simples arbres, engrenages et boîtes de vitesses le long d'un câble ne sont pas des périphériques du réseau : un câble peut longer une transmission. Contre l'ordinateur lui-même, ils le sont.
• Les autres ordinateurs du câble ne sont pas des périphériques : les ordinateurs se parlent avec net.
• Un côté de câble coupé à la clé ne laisse rien passer.
• Un réseau compte au plus 2048 câbles, et seulement dans les chunks chargés. Un nouveau câble est vu tout de suite, un bloc posé contre un câble en moins d'une seconde.
• Le Calculateur à tubes et l'Ordinateur à transistors n'ont pas de port réseau : ils n'atteignent que leurs six faces.

Les types. Ce qu'un bloc sait faire, c'est son type. Les méthodes de chaque type sont sur sa page :

Les deux dernières lignes n'existent que si Create Aeronautics est installé. Ce que tous les objets ont en commun est sur Tous les périphériques.

Plusieurs types. Un bloc peut être plusieurs choses à la fois : une meule de Create tourne (kinetic) et contient des objets (inventory), un bassin contient des objets et des fluides. Son objet a alors les méthodes de tous ses types réunies : meule.speed() et meule.count(). peripheral.type, la méthode type() et le nom réseau donnent le premier type, dans l'ordre du tableau ci-dessus (les types d'Aeronautics d'abord) ; peripheral.list(type) et peripheral.find(type) regardent tous les types : peripheral.find("inventory") trouve donc la meule, nommée kinetic@x,y,z sur le câble.

Vu d'un côté. Un inventaire ou un réservoir est vu depuis sa face qui touche l'ordinateur (ou le câble), comme le verrait un entonnoir de ce côté : un fourneau montre son emplacement d'entrée par le dessus, celui du combustible par le côté, et son résultat par le dessous.

Les coûts. La plupart des appels coûtent une instruction, mais parcourir un réseau câblé coûte davantage, car chaque bloc autour est interrogé :

Un câble droit de 20 blocs a environ 80 blocs autour de lui : peripheral.list() prend alors environ 340 instructions, plus qu'un tick entier d'un Mini-ordinateur. Cherchez vos périphériques une fois au début du programme, gardez les objets, et ne relancez la recherche que si l'installation change. Les méthodes ont leurs propres coûts, donnés sur la page de chaque type. Voir aussi Vitesse, mémoire et limites.

#Trouver des périphériques

for _, nom in ipairs(peripheral.list()) do
  print(nom, peripheral.type(nom))
end

back    kinetic
left    kinetic
inventory@120,64,-35    inventory
inventory@121,64,-35    inventory

local coffres = {}
for _, nom in ipairs(peripheral.list("inventory")) do
  if string.find(nom, "@") then  -- seulement les noms du câble : voir plus bas
    table.insert(coffres, peripheral.wrap(nom))
  end
end
print(#coffres .. " inventaires sur le câble")

while true do
  local fer = 0
  for _, coffre in ipairs(coffres) do
    fer = fer + coffre.count("minecraft:iron_ingot")
  end
  display.set({"Fer en stock", tostring(fer)})
  sleep(10)
end

local feu = peripheral.find("traffic_light")
if feu == nil then
  error("aucun feu tricolore trouvé")
end
feu.set("green")

local stock = peripheral.find("inventory")
local cuve = peripheral.find("tank")
local feu = peripheral.find("traffic_light")

while true do
  term.clear()
  term.set_cursor(1, 1)
  if stock then
    print("objets : " .. stock.count() .. " dans " .. stock.size() .. " emplacements")
  end
  if cuve then
    for _, t in ipairs(cuve.tanks()) do
      print((t.fluid or "vide") .. " : " .. t.amount .. "/" .. t.capacity .. " mB")
    end
  end
  if feu then
    print("feu : " .. feu.get())
  end
  if not (stock or cuve or feu) then
    print("rien à surveiller ici")
  end
  sleep(1)
end

while peripheral.type("left") ~= "inventory" do
  print("posez un coffre à gauche")
  sleep(2)
end
print("coffre trouvé")

#Piloter un périphérique

local coffre = peripheral.wrap("left")
if coffre == nil then
  error("posez le coffre renforcé à gauche")
end
print(coffre.type())   -- inventory
print(coffre.count())

local controleur = peripheral.wrap("right")   -- un Contrôleur de vitesse de rotation
local stock = peripheral.wrap("left")         -- le coffre renforcé de fer brut
while true do
  if stock.count("minecraft:raw_iron") > 1000 then
    controleur.set_speed(32)
  else
    controleur.set_speed(128)
  end
  sleep(5)
end

peripheral.call("left", "set", "red")
local charbon = peripheral.call("inventory@120,64,-35", "count", "minecraft:coal")
print(charbon .. " charbon")