Create: Computing AgesDoc Brass
Périphériques

Liaison de redstone

La redstone sans fil de Create, pilotée par la fréquence réglée dans un bloc de liaison : aucun identifiant d'objet à taper.

La Liaison de redstone de Create transmet la redstone sans fil : un émetteur et les récepteurs qui portent les deux mêmes objets dans leurs emplacements partagent une fréquence, jusqu'à 256 blocs de distance. Un ordinateur sait déjà émettre et écouter sur n'importe quelle fréquence avec la bibliothèque link, en tapant les identifiants des objets. Posez une Liaison de redstone contre l'ordinateur et il fait la même chose sur la fréquence réglée dans ce bloc : changez les objets à la main, et le programme suit, sans modifier une ligne.

Brass
local lien = peripheral.wrap("top")
lien.set(true)       -- tous les récepteurs de cette fréquence s'allument
print(lien.get())    -- le signal le plus fort des autres émetteurs
Méthodes
rl.get()La puissance de redstone qu'envoient les autres émetteurs de cette fréquence, la plus forte d'entre elles.
rl.set(power)Émet sur la fréquence du bloc, au nom de l'ordinateur.
rl.frequency()La fréquence du bloc : les identifiants des deux objets de ses emplacements, comme "minecraft:iron_ingot". Un emplacement vide se lit "minecraft:air".
rl.is_receiver()Indique si le bloc est réglé en récepteur.

Installation

La poser. Posez la Liaison de redstone contre une face de l'ordinateur, ou contre un Câble de données du réseau de l'ordinateur (à partir du Mini-ordinateur ; elle s'appelle alors par exemple redstone_link@120,64,-35). peripheral.find("redstone_link") prend la première trouvée. Réglez sa fréquence comme d'habitude dans Create : un objet dans chacun de ses deux emplacements. Accroupi + clic droit la fait passer d'émetteur à récepteur.

L'ordinateur est la radio, le bloc ne fait que porter la fréquence. lien.set et lien.get sont exactement link.set et link.get sur les deux objets du bloc : c'est l'ordinateur lui-même qui émet et écoute sur cette fréquence, depuis sa propre position. Donc :

  • lien.set(15) alimente tous les récepteurs de cette fréquence à portée de l'ordinateur, et aussi le bloc posé contre l'ordinateur s'il est en mode récepteur ;
  • lien.get() lit le signal le plus fort des émetteurs de cette fréquence à portée, y compris le bloc posé contre l'ordinateur quand c'est un émetteur alimenté par de la redstone (un levier posé dessus, par exemple). L'ordinateur n'entend jamais sa propre émission.

Relue à chaque appel. Chaque méthode regarde les objets des emplacements au moment où vous l'appelez. Changez les objets pendant que le programme tourne, et le prochain lien.set émet sur la nouvelle fréquence.

**Partagée avec la bibliothèque link.** Les fréquences qu'un programme utilise par des Liaisons de redstone et par link.get / link.set forment une seule table : une fréquence utilisée des deux façons est un seul et même canal, et un ordinateur en tient au plus 32 (too many link frequencies (max 32)). Dès qu'une fréquence a servi, chaque changement de ce qu'elle reçoit met en file un évènement link (e.a, e.b, e.power). Ce que l'ordinateur émet s'arrête quand il redémarre ou s'éteint. La portée est celle des Liaisons de redstone de Create, 256 blocs sauf si le serveur l'a changée. Les détails sont dans link.

Signal

#

rl.get()

→ number

La puissance de redstone qu'envoient les autres émetteurs de cette fréquence, la plus forte d'entre elles.

Renvoie
number
le signal le plus fort reçu sur la fréquence du bloc, de 0 à 15
Brass
local lien = peripheral.wrap("top")
if lien.get() > 0 then
  print("le levier du portail est abaissé")
end

Le premier appel lance aussi l'écoute : à partir de là, chaque changement de la puissance reçue met en file un évènement link, et le programme peut dormir au lieu de redemander sans cesse (voir les exemples plus bas).

Voir aussi redstone_link.set() link.get()

#

rl.set(power)

Émet sur la fréquence du bloc, au nom de l'ordinateur.

Paramètres
power number|boolean
une puissance de 0 à 15, ou true (15) et false (0)
Brass
local lien = peripheral.wrap("top")
lien.set(15)
lien.set(false)  -- éteint
lien.set(9)      -- 9 allume le vert d'un Feu tricolore posé à côté d'un récepteur

Une puissance au-dessus de 15 compte pour 15, en dessous de 0 pour 0. Un nombre à virgule arrête le programme avec bad argument #1 to 'set' (number has no integer representation) : arrondissez-le d'abord avec math.floor. La nouvelle puissance atteint le monde à la fin du tick du programme, et seule la dernière valeur de ce tick compte : une boucle qui la change des milliers de fois n'inonde pas le monde de mises à jour. L'émission dure après la fin du programme, même après une erreur ou Ctrl+T, jusqu'à ce que l'ordinateur redémarre ou s'éteigne (le déchargement de son chunk l'éteint aussi).

Voir aussi redstone_link.get() link.set()

Le bloc lui-même

#

rl.frequency()

→ table

La fréquence du bloc : les identifiants des deux objets de ses emplacements, comme "minecraft:iron_ingot". Un emplacement vide se lit "minecraft:air".

Renvoie
table
{a = id, b = id}, les identifiants des objets des deux emplacements du bloc

a et b viennent dans l'ordre où link.get et link.set les prennent : link.get(f.a, f.b) lit donc la même chose que lien.get().

Brass
local lien = peripheral.wrap("top")
local f = lien.frequency()
print("fréquence : " .. f.a .. " + " .. f.b)

Quand le bloc n'est plus une Liaison de redstone (cassée, remplacée), frequency, get et set arrêtent le programme avec redstone link not ready, et is_receiver renvoie false.

Voir aussi link.get() link.set()

#

rl.is_receiver()

→ boolean

Indique si le bloc est réglé en récepteur.

Renvoie
boolean
true quand le bloc est en mode récepteur, false pour un émetteur

Cela ne change pas ce que peut faire l'ordinateur (il émet et écoute à la fois), mais dit ce que le bloc lui-même fait de la redstone : un récepteur sort ce que porte la fréquence, un émetteur envoie la redstone qu'il reçoit.

Brass
local lien = peripheral.wrap("top")
if lien.is_receiver() then
  print("récepteur : affiche " .. lien.get())
else
  print("émetteur")
end

Exemples

Une alarme sans fil pour le coffre renforcé

La Liaison de redstone posée sur l'ordinateur porte la fréquence d'une lampe à l'autre bout de la base (un récepteur avec les deux mêmes objets à côté d'elle). Quand le Coffre à objet renforcé de Create à droite a de la place pour moins de 10 piles, la lampe s'allume.

Brass
local lien = peripheral.wrap("top")
local coffre = peripheral.wrap("right")
while true do
  local place = coffre.size() * 64 - coffre.count()  -- pour des objets qui s'empilent par 64
  lien.set(place < 640)
  sleep(5)
end

Pour déplacer l'alarme vers une autre lampe, changez les objets du bloc : le programme ne change pas.

Un levier à distance, sans interroger

Un levier sur un émetteur éloigné, avec les mêmes objets que le bloc posé contre l'ordinateur. Le programme ne se réveille que quand le levier bouge, et le recopie sur la sortie du dessous (une porte, un Embrayage ou un Inverseur de rotation de Create...).

Brass
local lien = peripheral.wrap("top")
rs.set("bottom", lien.get())  -- l'état actuel, et l'écoute commence
while true do
  local e = os.pull_event("link")
  local f = lien.frequency()
  if e.a == f.a and e.b == f.b then
    rs.set("bottom", e.power)
  end
end

Le test sur e.a et e.b garde le programme juste si quelqu'un change les objets du bloc : les évènements de l'ancienne fréquence sont ignorés.

Toutes les liaisons du réseau

Un relevé des Liaisons de redstone du câble de l'ordinateur : leur fréquence, leur mode, et ce qu'ils reçoivent.

Brass
for _, nom in ipairs(peripheral.list("redstone_link")) do
  local lien = peripheral.wrap(nom)
  local f = lien.frequency()
  local mode = "émetteur"
  if lien.is_receiver() then
    mode = "récepteur"
  end
  print(f.a .. " + " .. f.b .. " (" .. mode .. ") : " .. lien.get())
end

Chaque fréquence différente compte dans les 32 qu'un ordinateur peut utiliser.