net

L'adresse de cet ordinateur, le numéro que les autres utilisent pour lui envoyer un message. C'est la même chose que os.id().

print("Mon adresse : " .. net.id())

Notez-la sur une pancarte à côté de l'ordinateur, ou donnez un nom à l'ordinateur avec la commande label du shell (ou os.label) : net.computers montre le nom des ordinateurs joignables, et un programme peut ainsi trouver « l'entrepôt » sans connaître son numéro.

Voir aussi net.computers()

Envoie data à l'ordinateur dont l'adresse est id.

local USINE = 12
local ok = net.send(USINE, {type = "commande", objet = "minecraft:iron_ingot", nombre = 64}, "commandes")
if not ok then
  print("L'usine ne répond pas : hors de portée, éteinte ou saturée.")
end

net.send renvoie false quand aucun ordinateur de cette adresse n'est joignable (trop loin, dans un chunk non chargé, dans une autre dimension, ou c'est cet ordinateur lui-même), quand il est éteint, ou quand son tampon de réception est plein. Il n'attend pas : le programme continue tout de suite.

La donnée peut être omise, pour un message dont le canal dit tout :

net.send(12, nil, "ping")

De mauvais arguments arrêtent le programme : bad argument #1 to 'send' (number expected, got string) quand l'adresse n'est pas un nombre, bad argument #3 to 'send' (string expected, got number) quand le canal n'est pas une chaîne.

En plus de ses 32 instructions, un envoi coûte une instruction par valeur du message et une tous les 16 caractères (la copie), plus la recherche du destinataire : une instruction par case autour des Câbles de données de l'ordinateur et, sur un Micro-ordinateur, un Microcontrôleur ou un Ordinateur moderne, une par ordinateur chargé dans le monde. Sur un grand réseau, envoyez peu de gros messages plutôt que beaucoup de petits.

Voir aussi net.broadcast() net.receive()

Envoie data à tous les ordinateurs joignables, et renvoie combien l'ont accepté.

Une diffusion convient aux nouvelles qui peuvent intéresser n'importe qui : une mesure, une alarme, un « je suis là ». Les ordinateurs que ça ne concerne pas ignorent simplement le canal.

local nombre = net.broadcast("creeper à la porte nord !", "alarme")
print(nombre .. " ordinateurs prévenus")

Un ordinateur éteint, hors de portée ou saturé est sauté : il n'est pas compté, et il n'y a pas d'erreur. 0 veut dire que personne ne vous a entendu. Une diffusion coûte 64 instructions, plus la copie et la recherche comme net.send, plus 8 par ordinateur joignable.

Voir aussi net.send()

Attend le prochain message et le renvoie. Avec un timeout, abandonne au bout de ce nombre de secondes et renvoie nil.

print("J'écoute, je suis le n°" .. net.id())
while true do
  local m = net.receive()
  print("n°" .. m.sender .. " sur " .. m.channel .. " : " .. tostring(m.data))
end

Les champs d'un message, écrits ici à la main pour montrer ce que reçoit un programme :

local m = {name = "message", sender = 7, channel = "stock", via = "wifi", distance = 182.4,
  data = {objet = "minecraft:iron_ingot", nombre = 1830}}
print("du n°" .. m.sender .. " par " .. m.via .. ", à " .. m.distance .. " blocs")
print(m.data.objet .. " : " .. m.data.nombre)

du n°7 par wifi, à 182.4 blocs
minecraft:iron_ingot : 1830

Le délai est arrondi au tick suivant (un vingtième de seconde), et vaut au moins un tick : net.receive(0) renvoie un message déjà en attente, ou nil un tick plus tard. Mettez un délai dès qu'une réponse risque de ne jamais venir, pour que le programme ne reste pas bloqué :

net.send(12, nil, "ping")
local m = net.receive(2)
if m == nil then
  print("Pas de réponse en 2 secondes")
end

Les mêmes messages sortent de os.pull_event, qui permet d'attendre des messages et autre chose. os.pull_event("message") fait exactement comme net.receive(). Un ordinateur d'entrepôt qui annonce son stock toutes les 10 secondes et répond aux questions à tout moment :

local coffre = peripheral.wrap("back")
local minuteur = os.start_timer(10)
while true do
  local e = os.pull_event()
  if e.name == "message" and e.channel == "stock" and e.data == "combien ?" then
    net.send(e.sender, coffre.count("minecraft:iron_ingot"), "stock")
  elseif e.name == "timer" and e.id == minuteur then
    net.broadcast(coffre.count("minecraft:iron_ingot"), "stock")
    minuteur = os.start_timer(10)
  end
end

Filtrez ce que vous acceptez. N'importe quel ordinateur joignable peut envoyer sur n'importe quel canal : vérifiez le canal, l'expéditeur et la forme de la donnée avant d'agir. Une porte qui n'obéit qu'aux deux salles de contrôle :

local DE_CONFIANCE = {[4] = true, [9] = true}
local function accepter(m)
  return m.channel == "porte" and DE_CONFIANCE[m.sender] == true
end
print(accepter({sender = 4, channel = "porte", data = "ouvrir"}))
print(accepter({sender = 5, channel = "porte", data = "ouvrir"}))
print(accepter({sender = 9, channel = "chat", data = "salut"}))

true
false
false

Dans le vrai programme, accepter se place dans la boucle de réception : if accepter(m) then rs.set("top", m.data == "ouvrir") end. m.via == "cable" est un autre test utile : seul un ordinateur câblé au vôtre peut le passer.

Voir aussi net.send() os.pull_event() Évènements

Les ordinateurs auxquels celui-ci peut envoyer un message en ce moment, chacun sous forme de table :

Les ordinateurs du même câble viennent en premier. Un ordinateur éteint est dans la liste (il est joignable), mais net.send vers lui renvoie false.

for _, o in ipairs(net.computers()) do
  print("n°" .. o.id, o.via, o.distance .. " blocs", o.label or "")
end

Retrouvez un ordinateur par son nom plutôt que d'écrire son adresse dans le programme : il continuera de marcher le jour où vous remplacerez un ordinateur.

local function trouver(nom)
  for _, o in ipairs(net.computers()) do
    if o.label == nom then return o.id end
  end
  return nil
end

local entrepot = trouver("entrepot")
if entrepot then
  net.send(entrepot, "combien ?", "stock")
end

net.computers coûte 64 instructions plus la recherche (voir net.send) : appelez-la une fois au démarrage, pas à chaque tour de boucle.

Voir aussi net.send() net.networks()

Les réseaux Wi-Fi dont fait partie cet ordinateur : ceux de ses propres Routeurs Wi-Fi, et ceux des routeurs que ses radios atteignent. Chacun est une table :

for _, r in ipairs(net.networks()) do
  local genre = "voisin"
  if r.own then genre = "à moi" end
  print(r.ssid .. " : " .. r.routers .. " routeurs, le plus proche à " .. r.distance .. " blocs (" .. genre .. ")")
end

La liste est vide sur un Mini-ordinateur, sans routeur à portée, et avec des routeurs qui n'ont pas encore de SSID : un routeur reçoit son nom de réseau d'un programme, avec radio.set_ssid().

Voir aussi net.computers() radio.set_ssid()

Dit si l'ordinateur a une radio : un Modem radio ou un Routeur Wi-Fi qui le touche, ou n'importe où sur son réseau de Câbles de données. Toujours false sur un Mini-ordinateur, qui n'utilise que les câbles.

if not net.wireless() then
  print("Pas de radio : seuls les ordinateurs du câble m'entendront.")
end

#Motifs courants

Une messagerie. Chaque ligne tapée part vers tous les ordinateurs joignables ; les messages reçus entre-temps s'affichent après chaque ligne (appuyez sur Entrée sur une ligne vide pour voir les nouveaux). Les messages sont des tables avec le nom de l'auteur, pour que les autres sachent qui parle :

local moi = os.label() or ("n°" .. net.id())
print("Messagerie : vous êtes " .. moi .. ". Tapez /quitter pour sortir.")
while true do
  write("> ")
  local ligne = read()
  if ligne == "/quitter" then break end
  if ligne ~= "" then
    local auditeurs = net.broadcast({de = moi, texte = ligne}, "chat")
    print("(" .. auditeurs .. " à l'écoute)")
  end
  local m = net.receive(0)
  while m do
    if m.channel == "chat" and type(m.data) == "table" then
      print(tostring(m.data.de) .. " : " .. tostring(m.data.texte))
    end
    m = net.receive(0)
  end
end

Les messages qui arrivent pendant que read() attend votre ligne restent dans la file : aucun n'est perdu.

Une question avec délai et nouvelles tentatives. Un message peut se perdre : l'autre ordinateur était éteint, saturé, ou son chunk n'était pas chargé. Un client qui demande sa vitesse à l'usine essaie trois fois, et reconnaît la réponse grâce à un id qu'il met dans la question :

local USINE = 12
local prochain_id = 1

local function demander(question)
  local id = prochain_id
  prochain_id = prochain_id + 1
  for essai = 1, 3 do
    net.send(USINE, {type = "requete", id = id, question = question}, "usine")
    local limite = os.clock() + 2
    while os.clock() < limite do
      local m = net.receive(limite - os.clock())
      if m and m.sender == USINE and type(m.data) == "table"
          and m.data.type == "reponse" and m.data.id == id then
        return m.data.reponse
      end
    end
  end
  return nil
end

local tr_min = demander("vitesse")
if tr_min == nil then print("L'usine ne répond pas") else print("Usine à " .. tr_min .. " tr/min") end

Côté usine, chaque requête reçoit une réponse avec le même id :

local moteur = peripheral.wrap("top")   -- un Contrôleur de vitesse de rotation
while true do
  local m = net.receive()
  local d = m.data
  if m.channel == "usine" and type(d) == "table" and d.type == "requete" then
    local reponse = nil
    if d.question == "vitesse" then reponse = moteur.speed() end
    net.send(m.sender, {type = "reponse", id = d.id, reponse = reponse}, "usine")
  end
end

Une nouvelle tentative peut atteindre l'usine deux fois (quand seule la réponse s'est perdue) : gardez des requêtes qu'on peut répéter sans risque, « règle la vitesse à 64 » plutôt que « ajoute 16 tr/min ».

Des capteurs et un tableau de bord. Chaque capteur diffuse sa mesure toutes les quelques secondes sur le canal "capteurs" ; le tableau de bord garde la dernière mesure de chacun et se redessine chaque seconde, ce qui montre aussi l'âge de chaque valeur :

-- sur chaque capteur (un Microcontrôleur à côté d'un Coffre à objet renforcé)
local coffre = peripheral.wrap("back")
while true do
  net.broadcast({quoi = "fer", valeur = coffre.count("minecraft:iron_ingot")}, "capteurs")
  sleep(5)
end

-- sur le tableau de bord
local mesures = {}
while true do
  local m = net.receive(1)   -- nil au bout d'une seconde : de quoi redessiner quand même
  if m and m.channel == "capteurs" and type(m.data) == "table" then
    mesures[m.sender] = {quoi = m.data.quoi, valeur = m.data.valeur, quand = os.clock()}
  end
  term.clear()
  term.set_cursor(1, 1)
  for id, mesure in pairs(mesures) do
    local age = math.floor(os.clock() - mesure.quand)
    print("n°" .. id .. " " .. tostring(mesure.quoi) .. " : " .. tostring(mesure.valeur) .. " (il y a " .. age .. " s)")
  end
end

Un capteur dont l'âge ne cesse de grandir s'est tu : cassé, éteint, ou son chunk déchargé. Une version complète à trois ordinateurs, avec des ordres et des accusés de réception, se trouve dans Réseaux. Les programmes intégrés talk, listen et pong sont d'autres exemples complets.

Voir aussi net.networks()