Tous les périphériques

Un périphérique est un bloc que pilote un ordinateur : un Feu tricolore, un coffre, une machine de Create, un moniteur, un capteur de Create Aeronautics. peripheral.wrap et peripheral.find renvoient un objet pour lui : une table dont les champs sont les fonctions de ce bloc, ses méthodes. Cette page explique ce que tous ces objets ont en commun ; les pages de chaque type (listées plus bas) décrivent leurs méthodes.

local feu = peripheral.wrap("left")   -- le Feu tricolore de la face gauche
feu.set("green")
print(feu.get())                      -- green
print(feu.type())                     -- traffic_light

Tous les ordinateurs pilotent des périphériques, Calculateur à tubes compris : contre l'une de leurs six faces, ou, à partir du Mini-ordinateur, n'importe où sur leur réseau de Câble de données. Les noms, la recherche et les coûts sont expliqués dans peripheral.

#Appeler les méthodes

Avec un point, pas deux-points. Les méthodes d'un périphérique sont de simples fonctions rangées dans une table, pas des méthodes au sens de Lua : appelez-les avec un point, feu.set("green"). Avec deux-points, Brass passe l'objet lui-même en premier argument, et la méthode reçoit une table là où elle attendait du texte :

local feu = peripheral.wrap("left")
feu.set("red")     -- juste
feu:set("red")     -- faux : bad argument #1 to 'set' (string expected, got table)

Une table ordinaire. Un objet périphérique se range dans une variable ou une table, se passe à une fonction et se parcourt avec pairs. Une petite fonction liste les méthodes de n'importe quel périphérique, triées :

local function methodes(peripherique)
  local noms = {}
  for nom, _ in pairs(peripherique) do
    table.insert(noms, nom)
  end
  table.sort(noms)
  return table.concat(noms, " ")
end

for _, nom in ipairs(peripheral.list()) do
  print(nom .. " : " .. methodes(peripheral.wrap(nom)))
end

Pour un Feu tricolore, elle affiche get release set type. Le programme intégré devices va plus loin : il montre tout ce que l'ordinateur peut joindre, avec des mesures en direct.

Un objet ne vit que le temps du programme : après un redémarrage, refaites wrap sur le bloc.

#Types

Chaque périphérique a un type, un nom court en anglais qui dit ce qu'il sait faire. Voici tous les types, avec la page de leurs méthodes :

Les types de Create Aeronautics n'existent que si ce mod est installé.

Un bloc, plusieurs types. Un bloc peut être plusieurs choses à la fois. Une meule de Create tourne et contient des objets : elle est à la fois kinetic et inventory. Un bassin contient des objets et des fluides : inventory et tank. Son objet a alors les méthodes de tous ses types réunies, et un seul objet fait tout :

local meule = peripheral.wrap("left")
print(meule.speed() .. " tr/min")              -- une méthode de kinetic
print(meule.count() .. " objets dedans")       -- une méthode d'inventory

Son type, en revanche, est un seul nom : le premier de ses types, dans l'ordre du tableau ci-dessus (les types d'Aeronautics d'abord, puis de traffic_light jusqu'à tank). La meule est kinetic. Pour trouver un bloc par n'importe lequel de ses types, utilisez peripheral.list(type) ou peripheral.find(type), qui les regardent tous : peripheral.find("inventory") trouve aussi la meule.

local peripherique = peripheral.wrap("left")
if peripherique and peripherique.type() == "inventory" then
  print(peripherique.count() .. " objets")
end

#Quand le bloc disparaît

Un objet périphérique ne garde pas le bloc lui-même : chaque méthode cherche à nouveau le bloc au moment de l'appel. Un objet n'est donc jamais périmé. Cassez le coffre de gauche et posez-en un neuf : le même objet lit le nouveau coffre.

Quand le bloc a disparu, ou n'est plus du bon genre, la méthode arrête le programme avec une erreur :

Quelques lectures répondent nil au lieu d'échouer : le get d'un Feu tricolore disparu renvoie nil.

Les méthodes d'un objet sont choisies au moment de wrap. Si un bloc d'une autre sorte prend la place (un tonneau là où était le Feu tricolore), l'ancien objet garde les méthodes d'un Feu tricolore, qui échouent désormais : refaites wrap sur le bloc.

Pour qu'un programme survive à un bloc qui peut disparaître, appelez la méthode à travers pcall, qui renvoie une table au lieu d'arrêter le programme :

local coffre = peripheral.wrap("left")
while true do
  local resultat = pcall(coffre.count, "minecraft:coal")
  if resultat.ok then
    print("charbon : " .. resultat.value)
  else
    print("le coffre à charbon a disparu !")
  end
  sleep(5)
end

Pour en savoir plus sur la capture des erreurs : pcall et Erreurs et débogage.