Feu tricolore

Le Feu tricolore est un feu de circulation à trois lampes, rouge en haut, orange au milieu et vert en bas, comme les premiers feux électriques des années 1910. Tout seul, il suit la redstone. Dès qu'un ordinateur le règle, il affiche ce que demande votre programme, et la redstone ne le fait plus bouger tant que le programme ne lui a pas rendu la main.

local feu = peripheral.wrap("left")
feu.set("green")

#Installation

Le poser. Les feux sont tournés vers vous quand vous posez le bloc : placez-vous du côté d'où viendront les conducteurs. La Clé de Create le fait tourner ensuite.

Tout seul, il suit la redstone. Le signal le plus fort qu'il reçoit choisit l'aspect. Une horloge de redstone, un comparateur ou une Liaison de redstone de Create peuvent faire tourner un carrefour sans aucun ordinateur :

Le joindre depuis un ordinateur. Posez le feu contre une face de l'ordinateur et appelez-le par cette face : peripheral.wrap("left"). Sur un Mini-ordinateur ou un ordinateur plus récent, il peut aussi toucher un Câble de données du réseau de l'ordinateur : il prend alors le nom de ses coordonnées, comme traffic_light@120,64,-35. Et peripheral.find("traffic_light") prend le premier feu trouvé (les faces d'abord), sans nom à taper. Tous les ordinateurs peuvent le piloter, Calculateur à tubes compris. Voir Périphériques et Tous les périphériques.

#Commande

local feu = peripheral.wrap("left")
feu.set("red")
sleep(10)
feu.set("red_amber")
sleep(2)
feu.set("green")

local feu = peripheral.find("traffic_light")
if feu.get() == "red" then
  rs.set("top", true)  -- baisse la barrière du passage à niveau
end

local feu = peripheral.wrap("left")
feu.set("green")   -- les pompiers passent
sleep(15)
feu.release()      -- l'horloge de redstone reprend la main
print(feu.get())

#Exemples

#Un cycle complet

La séquence classique, comme au Royaume-Uni ou en Allemagne : vert, orange, rouge, puis rouge et orange ensemble juste avant le vert. Enregistrez-le sous le nom startup pour que le carrefour reparte tout seul au chargement du chunk.

local feu = peripheral.wrap("left")
if feu == nil then
  error("pas de feu tricolore à gauche")
end
while true do
  feu.set("green")
  sleep(20)
  feu.set("amber")
  sleep(3)
  feu.set("red")
  sleep(20)
  feu.set("red_amber")
  sleep(2)
end

Un vrai carrefour a deux feux qui ne doivent jamais être verts en même temps : la recette Carrefour intelligent les pilote depuis un seul ordinateur. Le programme intégré traffic attend une voiture sur une Boucle de détection avant de passer au rouge.

#Un passage piéton

La route reste au vert jusqu'à ce que quelqu'un appuie sur le bouton. Un feu est tourné vers la route, un second vers le passage piéton (le vert veut dire « traversez »), et un bouton en pierre est posé sur l'avant de l'ordinateur.

local voitures = peripheral.wrap("left")
local pietons = peripheral.wrap("right")
voitures.set("green")
pietons.set("red")
while true do
  os.pull_event("redstone")
  if rs.get("front") > 0 then
    sleep(3)                  -- les voitures ne s'arrêtent pas d'un coup
    voitures.set("amber")
    sleep(3)
    voitures.set("red")
    sleep(1)
    pietons.set("green")
    sleep(10)
    pietons.set("flashing")   -- dépêchez-vous
    sleep(4)
    pietons.set("red")
    sleep(1)
    voitures.set("red_amber")
    sleep(2)
    voitures.set("green")
  end
end

os.pull_event("redstone") dort jusqu'à ce qu'une entrée de redstone de l'ordinateur change : le programme ne coûte rien tant que personne ne vient. Le test rs.get("front") > 0 ne garde qu'un bouton enfoncé à cet instant : l'évènement du bouton qui ressort ne lance rien, pas plus qu'un ancien appui fait pendant que des gens traversaient (un bouton en pierre reste enfoncé une seconde).