Trains

Un ordinateur posé près d'une Station de train de Create sait quel train est à quai, lequel arrive, et où il pourrait aller depuis là. Il renomme les trains, lit et écrit leurs plannings, les assemble ou les démonte. Les Signaux de train et les Observateurs de train lui racontent ce qui se passe le long de la ligne. Avec eux, un programme fait tourner un dépôt, un tableau des arrivées ou tout un service de trains.

local gare = peripheral.find("station")
if gare.train_present() then
  print(gare.train_name() .. " est à quai à " .. gare.name())
end

#Installation

Trois blocs. La Station de train est un périphérique de type station, le Signal de train de type signal, l'Observateur de train de type track_observer. Posez-en un contre une face de l'ordinateur, ou contre un Câble de données de son réseau (à partir du Mini-ordinateur, il s'appelle alors comme station@120,64,-35), puis prenez-le : peripheral.wrap("left"), ou peripheral.find("station"). Voir Périphériques.

Sur un rail. Une station ou un signal ne fonctionne qu'une fois posé contre un rail, comme Create le pose (clic droit sur le rail avec le bloc d'abord). Sinon, la station arrête le programme avec station is not connected to a track, et le signal avec no signal: place it against a track.

Les trains sont partagés. Un train appartient à tout le serveur : un nom ou un planning changé par un programme est vu aussitôt par tous les joueurs et par toutes les autres stations.

Le train à quai. Beaucoup de méthodes agissent sur le train arrêté à la station. Quand il n'y en a pas, elles arrêtent le programme avec there is no train present : demandez d'abord train_present().

Pas d'évènements : demandez en boucle. Les périphériques ComputerCraft de Create envoient des évènements (train_arrival, train_passing...). Brass n'a pas d'évènements de périphériques : un programme redemande sans cesse, avec un court sleep entre deux questions. Une demi-seconde suffit largement pour des trains.

local gare = peripheral.find("station")
while not gare.train_present() do
  sleep(0.5)
end
print(gare.train_name() .. " est arrivé")

Pour faire autre chose pendant ce temps, voyez la boucle principale. Quand un bloc est cassé, ses méthodes arrêtent le programme avec station removed, signal removed ou track observer removed, et avec peripheral is not loaded quand son chunk n'est pas chargé.

#La station

local gare = peripheral.find("station")
print("Bienvenue à " .. gare.name())

local gare = peripheral.find("station")
while true do
  rs.set("top", gare.train_imminent())  -- une lampe au-dessus de l'ordinateur
  sleep(0.5)
end

local gare = peripheral.find("station")
if gare.train_present() then
  gare.set_train_name("Express du fer")
end

#Plannings

Un train suit son planning, celui écrit dans un Planning de train : une liste d'arrêts, chacun avec les conditions à attendre avant de repartir. Un programme le lit sous forme de table, et en donne un nouveau au train à quai. La table a la forme des données de planning de Create, avec leurs clés en snake_case (la même forme que le périphérique ComputerCraft de Create) :

local planning = {
  cyclic = true,
  entries = {
    {
      instruction = {id = "create:destination", data = {text = "Mine de fer"}},
      conditions = {
        { {id = "create:delay", data = {value = 20, time_unit = 1}} },
      },
    },
    {
      instruction = {id = "create:destination", data = {text = "Fonderie"}},
      conditions = {
        { {id = "create:idle", data = {value = 5, time_unit = 1}} },
      },
    },
  },
}

• cyclic : true recommence à la première entrée après la dernière ; false arrête le train après elle.
• entries : les étapes, dans l'ordre. Chacune a une instruction, {id =, data =}.
• conditions, pour une destination : une liste de groupes de conditions. Le train repart dès qu'un groupe est rempli, et un groupe est rempli quand ses conditions le sont, l'une après l'autre. L'interface de Create montre chaque groupe comme une colonne. Même une condition seule est dans son propre groupe : { {condition} }. Un arrêt sans aucune condition y garde le train pour de bon.

Les instructions et conditions courantes :

Pour toutes les autres, réglez-les dans un Planning de train en jeu, donnez-le à un train, et regardez ce que renvoie schedule().

local gare = peripheral.find("station")
if gare.train_present() and not gare.has_schedule() then
  print(gare.train_name() .. " n'a pas de planning")
end

local gare = peripheral.find("station")
local planning = gare.schedule()
for i, etape in ipairs(planning.entries) do
  if etape.instruction.id == "create:destination" then
    print(i .. ". " .. etape.instruction.data.text)
  end
end

local gare = peripheral.find("station")
local planning = gare.schedule()
planning.cyclic = false  -- encore un tour, puis arrêt
gare.set_schedule(planning)

#Où le train peut-il aller ?

Avant d'envoyer un train, un programme peut demander s'il peut seulement arriver : une station renommée, un rail cassé ou un signal manquant suffisent à couper une ligne. Ces deux méthodes regardent toutes les stations du réseau de rails du train dont le nom correspond à un filtre :

• * remplace n'importe quel texte, même vide : "Mine*" correspond à Mine, Mine 2 et Mine nord ;
• ? remplace exactement un caractère : "Quai ?" correspond à Quai 1 jusqu'à Quai 9, pas à Quai 10 ;
• tout le reste doit être identique, majuscules comprises. Un filtre fait 64 caractères au plus.

Les deux répondent pour le train arrêté à quai (sinon there is no train present), selon la façon dont la navigation de Create le conduirait : un train qui ne roule qu'en marche avant peut ne pas rejoindre une station qu'un autre train atteindrait. C'est la recherche dans le réseau qui les rend coûteuses.

local gare = peripheral.find("station")
if gare.can_reach("Mine de fer") then
  print("la ligne de la mine est ouverte")
else
  print("aucun chemin vers la mine d'ici")
end

local gare = peripheral.find("station")
local d = gare.distance_to("Carrière*")
if d then
  print("carrière la plus proche : " .. math.floor(d) .. " blocs")
end

#Assembler les trains

En mode assemblage, une station transforme les bogies et les blocs collés posés sur son rail en un train, et démonte un train en blocs. Ces méthodes font ce que font les boutons de l'interface de la station.

Comme un joueur qui clique sur ces boutons, une station change une fois par tick au plus : un deuxième set_assembly_mode, assemble ou disassemble sur la même station dans le même tick arrête le programme avec the station already changed this tick: sleep(0) waits for the next. Mettez un sleep(0) entre deux d'entre eux.

local gare = peripheral.find("station")
if not gare.assembling() then
  gare.set_assembly_mode(true)
  sleep(0)   -- un changement par tick
end
gare.assemble()
print(gare.train_name() .. " est prêt")

#Signal de train

Un Signal de train découpe la voie en sections, et ne laisse un train entrer dans la section qui le suit que si elle est libre. Un programme lit son feu, voit quels trains occupent la section, et peut le garder au rouge.

local sig = peripheral.find("signal")
if sig.state() == "red" then
  print("la section suivante est occupée")
end

local sig = peripheral.find("signal")
sig.set_forced_red(true)   -- travaux sur la ligne
sleep(120)
sig.set_forced_red(false)

local sig = peripheral.find("signal")
for _, nom in ipairs(sig.blocking_trains()) do
  print(nom .. " bloque le passage")
end

#Observateur de train

Un Observateur de train surveille un point de la voie et donne un signal de redstone pendant qu'un train passe. Quand un objet est réglé dans son filtre, seuls les trains qui transportent cette cargaison comptent.

local obs = peripheral.find("track_observer")
local compte = 0
local avant = false
while true do
  local maintenant = obs.train_passing()
  if maintenant and not avant then
    compte = compte + 1
    print(compte .. " : " .. (obs.passing_train() or "un train"))
  end
  avant = maintenant
  sleep(0.2)
end

#Exemples

#Un tableau des arrivées

Un ordinateur sur le quai, sans moniteur : son propre écran annonce chaque train. L'heure vient de l'horloge du monde (os.day_time()).

local gare = peripheral.find("station")
local dernier_train = "Le train"

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

local function situation()
  if gare.train_present() then return "a_quai" end
  if gare.train_imminent() then return "imminent" end
  if gare.train_enroute() then return "en_route" end
  return "vide"
end

term.clear()
term.set_cursor(1, 1)
print(gare.name())
local avant = "vide"
while true do
  local maintenant = situation()
  if maintenant ~= avant then
    if avant == "a_quai" then
      print(heure() .. "  " .. dernier_train .. " est parti")
    end
    if maintenant == "a_quai" then
      dernier_train = gare.train_name()
      print(heure() .. "  " .. dernier_train .. " est à quai")
    elseif maintenant == "imminent" then
      print(heure() .. "  arrivée : éloignez-vous du bord")
    elseif maintenant == "en_route" then
      print(heure() .. "  un train est en route")
    end
    avant = maintenant
  end
  sleep(0.5)
end

Le nom du train est gardé dans dernier_train tant qu'il est à quai : une fois parti, train_name() arrêterait le programme.

#Un dépôt qui n'envoie les trains que là où ils peuvent aller

Chaque train qui s'arrête au dépôt reçoit un nouveau planning : un aller vers la mine suivante, à tour de rôle, puis le retour au dépôt. Une mine dont la ligne est coupée est sautée, et quand aucune mine n'est accessible, le train attend au dépôt qu'une le redevienne.

local gare = peripheral.find("station")
local DEPOT = gare.name()
local MINES = {"Mine de fer", "Mine de charbon", "Carrière*"}
local tour = 1

-- un arrêt : aller à une station, y attendre quelques secondes
local function arret(station, secondes)
  return {
    instruction = {id = "create:destination", data = {text = station}},
    conditions = {
      { {id = "create:delay", data = {value = secondes, time_unit = 1}} },
    },
  }
end

-- la prochaine mine que le train à quai peut rejoindre, ou nil
local function mine_suivante()
  for i = 1, #MINES do
    local mine = MINES[tour]
    tour = tour % #MINES + 1
    if gare.can_reach(mine) then
      return mine
    end
  end
  return nil
end

local servi = false
while true do
  if not gare.train_present() then
    servi = false
  elseif not servi then
    local mine = mine_suivante()
    if mine then
      local blocs = math.floor(gare.distance_to(mine))
      gare.set_schedule({cyclic = false, entries = {arret(mine, 30), arret(DEPOT, 5)}})
      print(gare.train_name() .. " part pour " .. mine .. ", " .. blocs .. " blocs")
      servi = true
    end
  end
  sleep(2)
end

servi retient que le train à quai a reçu ses ordres, pour qu'il ne les reçoive qu'une fois. Quand il revient de la mine, il s'arrête de nouveau au dépôt et le programme l'envoie à la mine suivante. Un train sans mine accessible est redemandé toutes les deux secondes : un can_reach coûte 64 instructions, un tiers d'un tick de Calculateur à tubes, ne le demandez donc pas à chaque tick.