Un projet en plusieurs fichiers

-- trois petits fichiers, écrits ici pour que l'exemple tourne n'importe où
fs.write("/boutique/lib/monnaie", 'print("chargement de monnaie")\nreturn {ecrire = function(n) return n .. " pièces" end}')
fs.write("/boutique/lib/prix", 'local monnaie = import "monnaie"\nreturn {fer = monnaie.ecrire(4)}')
fs.write("/boutique/main", 'local prix = import "lib/prix"\nlocal monnaie = import "lib/monnaie"\nprint("fer : " .. prix.fer)\nprint(monnaie.ecrire(12))')
import "/boutique/main"
local r = pcall(import, "lib/or")
print(r.error)

chargement de monnaie
fer : 4 pièces
12 pièces
snippet:6: cannot import 'lib/or': no such file

-- startup : lancé au démarrage. Tout le programme vit dans le dossier panneau.
import "panneau/main"

-- panneau/main : un panneau de commande. Chaque face nommée dans /panneau.cfg reçoit
-- un bouton qui commute sa sortie de redstone. Lancé par /startup.
local config = import "lib/config"
local ui = import "lib/ui"
local log = import "lib/log"
local update = import "lib/update"

local VERSION = 3

local reglages = config.charger("/panneau.cfg", {
  titre = "PANNEAU DE COMMANDE",
  journal = "/panneau.log",
  taille_journal = 4000,
})
log.regler(reglages.journal, reglages.taille_journal)

-- Un bouton par face qui a un nom dans les réglages : left = Fours
local boutons = {}
for _, face in ipairs(rs.sides()) do
  if type(reglages[face]) == "string" then
    table.insert(boutons, {x = 3, y = 3 + #boutons * 2, l = 26, texte = reglages[face], face = face, actif = false})
  end
end

local function dessiner()
  ui.effacer()
  ui.entete(reglages.titre .. "   v" .. VERSION)
  for _, b in ipairs(boutons) do ui.bouton(b) end
  if #boutons == 0 then
    ui.etat("Ajoutez 'left = Lampes' à /panneau.cfg", term.colors.orange)
  else
    ui.etat("Cliquez un bouton. Journal : " .. reglages.journal)
  end
end

log.info("panneau v" .. VERSION .. " démarré")
dessiner()
while true do
  local e = os.pull_event()
  if e.name == "click" then
    for _, b in ipairs(boutons) do
      if ui.touche(b, e) then
        b.actif = not b.actif
        rs.set(b.face, b.actif)
        ui.bouton(b)
        log.info(b.texte .. (b.actif and " en marche" or " à l'arrêt"))
      end
    end
  elseif e.name == "message" then
    update.traiter(e)
  end
end

-- panneau/lib/config : lit un fichier de réglages fait de lignes "clé = valeur".
-- Les lignes qui commencent par # sont des commentaires ; nombres et true/false sont convertis.
local M = {}

-- "12" donne 12, "true" donne true, tout le reste reste du texte
local function convertir(texte)
  if texte == "true" then return true end
  if texte == "false" then return false end
  local n = tonumber(texte)
  if n then return n end
  return texte
end

-- Les réglages écrits dans un texte, sous forme de table
function M.analyser(texte)
  local reglages = {}
  for _, brute in ipairs(string.split(texte, "\n")) do
    local ligne = string.trim(brute)
    local egal = string.find(ligne, "=")
    if egal and not string.starts(ligne, "#") then
      local cle = string.trim(string.sub(ligne, 1, egal - 1))
      reglages[cle] = convertir(string.trim(string.sub(ligne, egal + 1)))
    end
  end
  return reglages
end

-- Écrit les réglages dans un fichier que le joueur peut modifier
function M.enregistrer(chemin, reglages)
  local lignes = {"# Réglages : une ligne 'clé = valeur' par réglage"}
  for k, v in pairs(reglages) do
    table.insert(lignes, k .. " = " .. tostring(v))
  end
  fs.write(chemin, table.concat(lignes, "\n") .. "\n")
end

-- Les réglages de chemin, complétés par les valeurs par défaut. Un fichier absent est
-- créé à partir d'elles, pour qu'il y ait quelque chose à modifier.
function M.charger(chemin, defauts)
  local texte = fs.read(chemin)
  if texte == nil then
    M.enregistrer(chemin, defauts)
    texte = ""
  end
  local reglages = M.analyser(texte)
  for k, v in pairs(defauts) do
    if reglages[k] == nil then reglages[k] = v end
  end
  return reglages
end

return M

-- panneau/lib/ui : des aides au dessin pour les écrans de texte.
local M = {}
local couleurs = term.colors

function M.effacer()
  term.set_bg(couleurs.black)
  term.clear()
end

-- Une barre bleue en haut de l'écran
function M.entete(titre)
  term.set_cursor(1, 1)
  term.set_bg(couleurs.blue)
  term.set_fg(couleurs.white)
  term.write(" " .. titre .. string.rep(" ", term.get_size().w))   -- coupé au bord
  term.set_bg(couleurs.black)
end

-- Un bouton est une table {x =, y =, l =, texte =, actif =} : vert en marche, rouge à l'arrêt
function M.bouton(b)
  local etat = b.actif and "MARCHE" or "ARRÊT"
  local texte = " " .. b.texte
  term.set_cursor(b.x, b.y)
  term.set_bg(b.actif and couleurs.green or couleurs.red)
  term.set_fg(couleurs.white)
  term.write(texte .. string.rep(" ", b.l - #texte - #etat - 1) .. etat .. " ")
  term.set_bg(couleurs.black)
end

-- Le clic e est-il tombé sur le bouton ?
function M.touche(b, e)
  return e.y == b.y and e.x >= b.x and e.x < b.x + b.l
end

-- Une ligne de texte en bas de l'écran
function M.etat(texte, couleur)
  term.set_cursor(1, term.get_size().h)
  term.set_bg(couleurs.black)
  term.clear_line()
  term.set_fg(couleur or couleurs.light_gray)
  term.write(texte)
end

return M

-- panneau/lib/log : un journal de lignes datées qui ne grossit jamais trop.
local M = {}
local chemin = "/programme.log"   -- changé par M.regler
local octets_max = 4000

function M.regler(fichier, taille)
  chemin, octets_max = fichier, taille
end

local function heure()
  local t = (os.day_time() + 6000) % 24000
  return string.format("%02d:%02d", t // 1000, t % 1000 * 60 // 1000)
end

local function ajouter(ligne)
  local taille = fs.size(chemin)
  if taille and taille > octets_max then
    fs.move(chemin, chemin .. ".old")   -- remplace l'ancien journal précédent
  end
  fs.append(chemin, ligne .. "\n")
end

-- Un disque plein ne doit pas arrêter le programme : la ligne est perdue, c'est tout
function M.ecrire(niveau, texte)
  pcall(ajouter, heure() .. " " .. niveau .. " " .. texte)
end

function M.info(texte)
  M.ecrire("INFO", texte)
end

function M.alerte(texte)
  M.ecrire("ALERTE", texte)
end

return M

-- panneau/lib/update : installe une nouvelle version du programme envoyée par "publier".
local log = import "log"   -- panneau/lib/log : le même module que celui de main

local M = {}
local SECRET = "atelier-laiton-7"
local CANAL = "maj"

local function installer(fichiers)
  for chemin, texte in pairs(fichiers) do
    fs.write("/" .. chemin, texte)
  end
end

-- Appelée par main pour chaque évènement "message" : true si c'était une nouvelle version
function M.traiter(e)
  local d = e.data
  if e.channel ~= CANAL or type(d) ~= "table" or d.secret ~= SECRET or type(d.fichiers) ~= "table" then
    return false
  end
  local r = pcall(installer, d.fichiers)
  if not r.ok then
    log.alerte("mise à jour " .. tostring(d.version) .. " ratée : " .. r.error)
    net.send(e.sender, {secret = SECRET, version = d.version, ok = false, erreur = r.error}, CANAL)
    return true
  end
  log.info("mis à jour en version " .. tostring(d.version) .. " par n°" .. e.sender)
  net.send(e.sender, {secret = SECRET, version = d.version, ok = true}, CANAL)
  os.reboot()   -- les nouveaux fichiers repartent du début
  return true
end

return M

local M = {}
local couleurs = term.colors
function M.effacer()
  term.set_bg(couleurs.black)
  term.clear()
end
function M.entete(titre)
  term.set_cursor(1, 1)
  term.set_bg(couleurs.blue)
  term.set_fg(couleurs.white)
  term.write(" " .. titre .. string.rep(" ", term.get_size().w))
  term.set_bg(couleurs.black)
end
function M.bouton(b)
  local etat = b.actif and "MARCHE" or "ARRÊT"
  local texte = " " .. b.texte
  term.set_cursor(b.x, b.y)
  term.set_bg(b.actif and couleurs.green or couleurs.red)
  term.set_fg(couleurs.white)
  term.write(texte .. string.rep(" ", b.l - #texte - #etat - 1) .. etat .. " ")
  term.set_bg(couleurs.black)
end
function M.etat(texte, couleur)
  term.set_cursor(1, term.get_size().h)
  term.set_bg(couleurs.black)
  term.clear_line()
  term.set_fg(couleur or couleurs.light_gray)
  term.write(texte)
end

local ui = M
ui.effacer()
ui.entete("HALLE DE FONTE   v3")
ui.bouton({x = 3, y = 3, l = 26, texte = "Fours", actif = true})
ui.bouton({x = 3, y = 5, l = 26, texte = "Convoyeur", actif = false})
ui.bouton({x = 3, y = 7, l = 26, texte = "Lumières", actif = true})
ui.etat("Cliquez un bouton. Journal : /panneau.log")

Écran

-- cloner : copie des fichiers et des dossiers sur d'autres disques.
-- Usage, depuis la racine : cloner startup panneau   puis changez de disque quand il le demande.
if #arg == 0 then
  print("Usage : cloner <fichier ou dossier> ...")
  return
end

-- 1. Tout est lu en mémoire, tant que le disque d'origine est dans le lecteur
local fichiers = {}
local nombre, octets = 0, 0
local function rassembler(chemin)
  if fs.is_dir(chemin) then
    for _, nom in ipairs(fs.list(chemin)) do
      rassembler(chemin .. "/" .. nom)
    end
  else
    local texte = fs.read(chemin)
    if texte == nil then error("pas de fichier '" .. chemin .. "'") end
    fichiers[chemin] = texte
    nombre, octets = nombre + 1, octets + #texte
  end
end
for _, nom in ipairs(arg) do
  rassembler(nom)
end
print(nombre .. " fichiers lus, " .. octets .. " octets.")

local function tout_ecrire()
  for chemin, texte in pairs(fichiers) do
    fs.write(chemin, texte)
  end
end

-- 2. Un évènement "disk" arrive quand un disque quitte le lecteur et quand un autre y entre
while true do
  print("Éjectez le disque (accroupi + clic droit main vide) et insérez-en un neuf. Ctrl+T pour arrêter.")
  repeat
    local e = os.pull_event("disk")
  until e.inserted
  local r = pcall(tout_ecrire)
  if r.ok then
    print("Copié. " .. fs.free() .. " octets libres sur ce disque.")
  else
    print("Échec : " .. r.error)
  end
end

-- publier : envoie le programme à tous les ordinateurs dont l'étiquette commence par
-- "panneau", et attend la réponse de chacun. Usage : publier 4   (le numéro de version)
local SECRET = "atelier-laiton-7"
local CANAL = "maj"
local PREFIXE = "panneau"   -- les étiquettes des ordinateurs à mettre à jour
local DELAI = 3             -- secondes d'attente des réponses
local ESSAIS = 3

local version = tonumber(arg[1])
if version == nil then
  print("Usage : publier <numéro de version>")
  return
end

-- Tous les fichiers d'un dossier et de ses sous-dossiers : fichiers["panneau/lib/ui"] = "..."
local function rassembler(dossier, fichiers)
  for _, nom in ipairs(fs.list("/" .. dossier)) do
    local chemin = dossier .. "/" .. nom
    if fs.is_dir("/" .. chemin) then
      rassembler(chemin, fichiers)
    else
      fichiers[chemin] = fs.read("/" .. chemin)
    end
  end
end

local fichiers = {startup = fs.read("/startup")}
rassembler("panneau", fichiers)
local taille = 0
for _, texte in pairs(fichiers) do taille = taille + #texte end
if taille > 30000 then error("le programme est trop gros pour un seul message : " .. taille .. " caractères") end

-- Les ordinateurs à mettre à jour, trouvés par leur étiquette
local cibles = {}
local nombre = 0
for _, c in ipairs(net.computers()) do
  if c.label and string.starts(c.label, PREFIXE) then
    cibles[c.id] = {etiquette = c.label, essais = 0, fini = false}
    nombre = nombre + 1
  end
end
print("Version " .. version .. ", " .. taille .. " caractères, vers " .. nombre .. " ordinateur(s)")

local message = {secret = SECRET, version = version, fichiers = fichiers}

-- Envoie à ceux qui n'ont pas répondu ; renvoie le nombre d'envois
local function envoyer_tour()
  local envoyes = 0
  for id, c in pairs(cibles) do
    if not c.fini and c.essais < ESSAIS then
      c.essais = c.essais + 1
      net.send(id, message, CANAL)
      envoyes = envoyes + 1
    end
  end
  return envoyes
end

local function tous_finis()
  for _, c in pairs(cibles) do
    if not c.fini then return false end
  end
  return true
end

-- Une réponse : {secret =, version =, ok =, erreur =} venue de l'une des cibles
local function sur_reponse(e)
  local d = e.data
  if e.name ~= "message" or e.channel ~= CANAL or cibles[e.sender] == nil then return end
  if type(d) ~= "table" or d.secret ~= SECRET or d.version ~= version then return end
  local c = cibles[e.sender]
  c.fini = true
  if d.ok then
    print("n°" .. e.sender .. " " .. c.etiquette .. " : à jour")
  else
    print("n°" .. e.sender .. " " .. c.etiquette .. " : échec, " .. tostring(d.erreur))
  end
end

while envoyer_tour() > 0 do
  local minuterie = os.start_timer(DELAI)
  while not tous_finis() do
    local e = os.pull_event()
    if e.name == "timer" and e.id == minuterie then break end
    sur_reponse(e)
  end
end

for id, c in pairs(cibles) do
  if not c.fini then print("n°" .. id .. " " .. c.etiquette .. " : pas de réponse") end
end

-- recevoir : à taper une fois sur un nouvel ordinateur, après lui avoir donné une
-- étiquette (label panneau-4), puis lancez publier à l'atelier. Il installe et redémarre.
local SECRET = "atelier-laiton-7"
print("J'attends le programme, je suis le n°" .. net.id())
while true do
  local m = net.receive()
  local d = m.data
  if m.channel == "maj" and type(d) == "table" and d.secret == SECRET and type(d.fichiers) == "table" then
    for chemin, texte in pairs(d.fichiers) do
      fs.write("/" .. chemin, texte)
    end
    net.send(m.sender, {secret = SECRET, version = d.version, ok = true}, "maj")
    os.reboot()
  end
end