Create: Computing AgesDoc Brass
Périphériques

Blocs de Create: Connected

Les blocs de Create: Connected pilotés par un ordinateur : la charge de la batterie cinétique, les embrayages, le programme du générateur d'impulsion séquencé, les lignes du tableau de bord, les leviers et boutons liés, le pont cinétique.

Il faut Create: Connected

Tout ce qui se trouve sur cette page n'existe que si Create: Connected est installé. Sans lui, aucun de ces blocs n'existe, et peripheral.find("kinetic_battery") renvoie nil.

Create: Connected ajoute de petits blocs entre la cinétique et la redstone. Un ordinateur relié à eux lit ce que montrent les Lunettes d'ingénieur et leurs écrans, et règle ce qu'un joueur règle à la main : la charge d'une batterie cinétique et le moment où elle rend sa rotation, le moment où un embrayage s'accouple, le programme d'un générateur d'impulsion séquencé, les lignes qu'un joueur assis voit depuis un tableau de bord, et des leviers et des boutons qui émettent sur une fréquence de Liaison de redstone.

Les blocs portent leur nom français du jeu ; ceux que la traduction du mod ne couvre pas gardent leur nom anglais, indiqué entre parenthèses.

Bloc (nom en jeu)type de périphériquece qu'il lit ou règle
Batterie cinétiquekinetic_batterysa charge en SU-heures, et son sens de rotation quand elle se décharge
Poignée de surchargeoverstress_clutchson état et son délai ; la réaccouple comme une clé
Embrayage centrifugecentrifugal_clutchs'il est accouplé, son seuil de vitesse et son mode
Poignée à roue librefreewheel_clutchsi elle est accouplée, et le sens qu'elle laisse passer
Générateur d'impulsion séquencésequenced_pulse_generatorson programme, l'étape en cours, son entrée et sa sortie
tableau de bord (Dashboard)dashboardses 4 lignes de texte et leur couleur
Levier liélinked_leversa fréquence et sa position ; l'actionne
Bouton lié (de tout bois ou pierre)linked_buttonsa fréquence ; l'enfonce
Levier analogique liélinked_analog_leversa fréquence et son signal ; le tourne
levier d'accélération lié (Linked Throttle Lever, avec Create Simulated)linked_throttle_leversa fréquence et son signal ; le déplace
Pont cinétiquekinetic_bridgela contrainte qu'il passe d'un réseau à l'autre

La poignée de surcharge (Overstress Clutch) et la poignée à roue libre (Freewheel Clutch) sont des embrayages, malgré leur nom français. Les quatre blocs liés partagent leurs méthodes, notées linked_transmitter plus bas : chaque méthode dit lesquels l'ont. Create: Connected n'a pas de périphériques ComputerCraft à lui : ces méthodes sont celles de ce mod, et elles font ce que font les panneaux de réglage, les écrans et la main d'un joueur.

Atteindre un bloc. Contre l'ordinateur, un bloc s'appelle par sa face ("left"...) ; sur un Câble de données (Mini-ordinateur et plus récents), il reçoit un nom comme kinetic_battery@12,64,-30. peripheral.find prend le premier d'un type.

Brass
local bat = peripheral.find("kinetic_battery")
print(bat.charge() .. " / " .. bat.max_charge() .. " SU-heures, " .. bat.status())

Chaque appel relit le bloc, si bien qu'un bloc enveloppé n'est jamais périmé. Chaque méthode qui change un bloc agit à la fin du tick du programme, comme le clic d'un joueur, avec la dernière valeur demandée dans ce tick : relisez le bloc après un sleep pour voir le changement. Quand quelque chose ne va pas, l'appel arrête le programme avec une erreur que l'on peut attraper avec pcall :

erreurquand
kinetic battery removedle bloc a été cassé ou remplacé depuis peripheral.wrap (son type, avec des espaces)
peripheral is not loadedle chunk du bloc n'est pas chargé
bad argument #1 to 'set_delay' (...)un mauvais argument : le texte entre parenthèses dit ce qui est attendu
this version of Create: Connected has no getBatteryLevelvotre version de Create: Connected n'a pas ce dont la méthode se sert (le nom à la fin)
Create: Connected error: ...le bloc lui-même a échoué en répondant

Aussi des blocs cinétiques. La batterie, les trois embrayages et le pont tournent : ils ont en plus les méthodes de Blocs cinétiques de Create (speed(), stress(), capacity(), overstressed()), et aucune des leurs ne porte l'un de ces noms. Sur un embrayage, speed() est la vitesse de l'embrayage lui-même, du côté d'où vient la rotation : c'est coupled() ou state() qui dit si l'autre côté tourne. Les autres blocs de Create: Connected (ses boîtes à roues dentées, la chute en laiton, le silo à objet, la citerne à fluide...) n'ont pas de type à eux : Blocs cinétiques de Create, Inventaires et Réservoirs les couvrent.

Méthodes
bat.charge()Ce que contient la batterie, en SU-heures, arrondi à 3 décimales : le premier nombre que montrent les Lunettes d'ingénieur sous « Charge ».
bat.max_charge()La capacité d'une batterie, en SU-heures : 512, sauf si le serveur a changé batteryCapacity. Toutes les batteries ont la même.
bat.discharging()true tant que la batterie reçoit de la redstone, sur une de ses faces ou par une batterie de sa chaîne : elle donne alors de la rotation au lieu d'en prendre, tant qu'il lui reste de la charge. false en mode charge.
bat.status()L'« État de la batterie » des lunettes. Sans redstone, "charging" (« Recharge en cours »), puis "full" (« Plein ») une fois pleine ; avec redstone, "discharging" (« En décharge »), puis "empty" (« Vide ») une fois vide. "charging" veut dire que la batterie est prête à prendre de la rotation, pas que de la rotation lui arrive : regardez charge() augmenter pour en être sûr.
bat.consumption()Ce que la batterie dépense en ce moment, en SU par tick, la « Charge Consumption » des lunettes : la contrainte que le réseau utilise au-delà de ce que donnent ses autres sources, partagée entre ses batteries qui se déchargent ; 0 quand elles suffisent. Sans autre charge, une batterie qui entraîne des tapis dépense quand même 1 SU par tick (configuration serveur batteryMinDischarge). Lisez-la pendant que la batterie se décharge : les lunettes ne la montrent qu'à ce moment-là.
bat.direction()Le sens dans lequel la batterie tourne quand elle se décharge, celui de son panneau de réglage (« Direction de rotation pendant la décharge »).
bat.set_direction(way)Règle le panneau, à la fin du tick : une batterie qui se décharge tourne aussitôt dans l'autre sens. Un autre mot arrête le programme avec bad argument #1 to 'set_direction' ("clockwise" or "counter_clockwise").
embrayage.state()Où en est la poignée. Un comparateur contre elle lit 0 quand elle est désaccouplée, 15 sinon.
embrayage.delay()Le délai de son panneau de réglage (« Dé-coupler le délai » en jeu), en ticks (20 par seconde), de 1 à 72000 (une heure). Une poignée neuve attend 1 tick.
embrayage.set_delay(ticks)Règle le délai, gardé entre 1 et 72000, à la fin du tick. N'importe quel nombre entier de ticks convient, là où le panneau compte en ticks, en secondes ou en minutes. Un délai plus court qu'un décompte en cours raccourcit aussi ce décompte. Un nombre à virgule arrête le programme avec bad argument #1 to 'set_delay' (number has no integer representation).
embrayage.countdown()Tant que l'état est "uncoupling", le nombre de ticks qui restent avant que la poignée se désaccouple ; 0 dans les deux autres états.
embrayage.reset()Réaccouple la poignée, comme une clé, à la fin du tick. Renvoie false, sans rien faire, quand elle n'était pas désaccouplée. Comme la clé, elle reste sans effet tant que le réseau de la poignée est encore en surcharge, et si la surcharge revient une fois accouplée, le décompte repart.
cc.coupled()true tant que l'embrayage transmet sa rotation, false tant qu'il est désaccouplé.
cc.threshold()La vitesse du panneau de réglage, en tr/min, quel que soit le mode.
cc.mode()La ligne choisie sur le panneau : "min" est « Minimum Speed » (≥), "max" est « Maximum Speed » (≤).
cc.set_threshold(rpm)Règle le seuil, gardé entre 1 et 256, et garde le mode ; à la fin du tick. Un nombre à virgule arrête le programme avec bad argument #1 to 'set_threshold' (number has no integer representation).
cc.set_mode(mode)Change de mode et garde le seuil, à la fin du tick. Un autre mot arrête le programme avec bad argument #1 to 'set_mode' (min, max).
fw.coupled()true tant que l'entrée tourne dans le bon sens et que la poignée la transmet.
fw.direction()Le sens de son panneau de réglage (« Direction de la rotation »).
fw.set_direction(way)Règle le panneau, à la fin du tick ; la poignée s'accouple ou se désaccouple aussitôt si son entrée tourne maintenant dans le bon ou le mauvais sens. Un autre mot arrête le programme avec bad argument #1 to 'set_direction' ("clockwise" or "counter_clockwise").
gen.running()true de l'impulsion qui lance le programme jusqu'à ce qu'il se termine ou soit arrêté.
gen.output()La puissance à son avant en ce moment : le signal de l'instruction en cours, 0 au repos.
gen.input()La puissance qui arrive à son arrière : celle qui le lance, et celle que lisent les instructions wait_for, loop_if et transform.
gen.step()L'instruction qui s'exécute, comptée à partir de 1 comme les lignes de l'écran et la liste de instructions() ; nil tant que le générateur attend une impulsion.
gen.instructions()Le programme, tel que le montre son écran, avec son end. value manque pour loop et end, et signal pour les boucles et end, qui n'en ont pas.
gen.set_instructions(list)Remplace le programme et arrête le générateur, à la fin du tick : sa sortie passe à 0, et le nouveau programme attend la prochaine impulsion à son arrière. La liste est vérifiée comme l'écran la vérifie :
gen.stop()Arrête le programme et met la sortie à 0, comme un signal sur l'un de ses côtés, à la fin du tick. Le programme reste ; la prochaine impulsion à son arrière le rejoue depuis le début.
dash.lines()Le texte des 4 lignes, quel que soit son auteur (un joueur, une Liaison d'affichage, un ordinateur).
dash.set_line(n, text)Écrit une ligne, à la fin du tick ; les trois autres restent. Un texte de plus de 64 caractères est coupé. Le bloc lui-même affiche environ 15 caractères par ligne, la ligne de messages la ligne entière. Un autre numéro de ligne arrête le programme avec bad argument #1 to 'set_line' (line 1 to 4). Pour vider une seule ligne, écrivez "".
dash.clear()Vide les 4 lignes, comme un clic à main nue, à la fin du tick.
dash.color()La teinture du texte, comme "white" (un tableau de bord neuf) ou "light_blue".
dash.set_color(color)Teint le texte, à la fin du tick, sur le bloc et dans la ligne de messages. "grey" vaut "gray" ; un autre mot arrête le programme avec une erreur qui donne les 16 noms. Un texte lumineux le reste.
dash.open()true tant que le tableau de bord envoie son texte au joueur assis devant lui ; false une fois qu'une clé a coupé cet envoi. Le bloc affiche son texte dans les deux cas, et un programme l'écrit dans les deux cas.
levier.frequency()La fréquence sur laquelle il émet, en identifiants d'objets ; "minecraft:air" pour un emplacement vide. Les quatre blocs liés l'ont.
levier.powered()true tant que le levier est activé, et émet 15. Levier lié seulement.
levier.set_powered(on)Actionne le levier comme un joueur, à la fin du tick, quand il n'est pas déjà dans cette position : il claque, alimente les blocs autour de lui et émet. Levier lié seulement. Autre chose qu'un booléen arrête le programme avec bad argument #1 to 'set_powered' (boolean expected, got number).
bouton.pressed()true tant que le bouton est enfoncé, et émet 15. Bouton lié seulement.
bouton.press()Enfonce le bouton comme un joueur, à la fin du tick : il émet jusqu'à ce qu'il ressorte, au bout d'une seconde pour un bouton de pierre et d'une seconde et demie pour un bouton de bois. Renvoie false, sans rien faire, tant que le bouton est déjà enfoncé. Bouton lié seulement.
levier.signal()La position du levier, de 0 à 15 : le signal qu'il donne et émet. Levier analogique lié et levier d'accélération lié.
levier.set_signal(power)Amène le levier sur ce signal, gardé entre 0 et 15, à la fin du tick. Levier analogique lié et levier d'accélération lié. Un levier analogique tourne cran par cran, comme sous la main d'un joueur : signal() donne aussitôt la nouvelle position, mais sa sortie et ce qu'il émet suivent 15 ticks (0,75 s) après le dernier cran. Un levier d'accélération émet le nouveau signal aussitôt, et donne le signal demandé même quand une clé l'a inversé.
pont.stress_impact()Le panneau de réglage, en SU par tr/min, arrondi à 3 décimales : sous 16 les crans ont des décimales (1.072, 1.149...), à partir de 16 ce sont des nombres entiers.
pont.set_stress_impact(su)Prend le cran du panneau le plus proche, entre 1 et 65536, à la fin du tick, et le renvoie aussitôt.

Batterie cinétique

La batterie cinétique stocke de la rotation. Sans redstone, elle se charge : elle est une charge pour le réseau branché à son avant (64 SU par tr/min avec les réglages par défaut) et stocke ce qu'elle consomme. Avec un signal de redstone sur une face, elle se décharge : elle fait tourner son avant à une vitesse fixe (64 tr/min par défaut, configuration serveur de Create: Connected batteryDischargeRPM), dans le sens que dit son panneau de réglage, et donne jusqu'à 32 SU par tr/min. Une batterie qui se décharge ne dépense que la contrainte que le réseau utilise au-delà de ses autres sources : quand elles suffisent, elle ne dépense rien. Des batteries alignées, tournées dans le même sens, partagent leur redstone : une batterie alimentée fait se décharger toute la chaîne.

La charge se compte en SU-heures, l'unité que montrent les Lunettes d'ingénieur (« su-heures ») : une SU-heure est ce qu'une charge de 1 SU dépense en une heure (72 000 ticks). Une batterie contient 512 SU-heures par défaut (configuration serveur batteryCapacity) : une charge de 256 SU la vide donc en 2 heures. Un ordinateur la fait se décharger en lui donnant de la redstone : rs.set quand il touche la batterie, sinon une Liaison de redstone posée contre elle (link).

#

bat.charge()

→ number

Ce que contient la batterie, en SU-heures, arrondi à 3 décimales : le premier nombre que montrent les Lunettes d'ingénieur sous « Charge ».

Renvoie
number
la charge qu'elle contient, en SU-heures
Brass
local bat = peripheral.find("kinetic_battery")
print(string.format("%.1f SU-heures", bat.charge()))

Voir aussi kinetic_battery.max_charge() kinetic_battery.consumption()

#

bat.max_charge()

→ number

La capacité d'une batterie, en SU-heures : 512, sauf si le serveur a changé batteryCapacity. Toutes les batteries ont la même.

Renvoie
number
la charge qu'elle peut contenir au plus, en SU-heures
Brass
local bat = peripheral.find("kinetic_battery")
print(math.floor(bat.charge() / bat.max_charge() * 100) .. " %")

Voir aussi kinetic_battery.charge()

#

bat.discharging()

→ boolean

true tant que la batterie reçoit de la redstone, sur une de ses faces ou par une batterie de sa chaîne : elle donne alors de la rotation au lieu d'en prendre, tant qu'il lui reste de la charge. false en mode charge.

Renvoie
boolean
true tant que la redstone la fait se décharger
Brass
local bat = peripheral.find("kinetic_battery")
if bat.discharging() then
  print("Sur batterie")
end

Voir aussi kinetic_battery.status()

#

bat.status()

→ string

L'« État de la batterie » des lunettes. Sans redstone, "charging" (« Recharge en cours »), puis "full" (« Plein ») une fois pleine ; avec redstone, "discharging" (« En décharge »), puis "empty" (« Vide ») une fois vide. "charging" veut dire que la batterie est prête à prendre de la rotation, pas que de la rotation lui arrive : regardez charge() augmenter pour en être sûr.

Renvoie
string
"charging", "discharging", "full" ou "empty"
Brass
local bat = peripheral.wrap("left")
if bat.status() == "empty" then
  rs.set("left", false)   -- retour en charge
end

Voir aussi kinetic_battery.discharging()

#

bat.consumption()

→ number

Ce que la batterie dépense en ce moment, en SU par tick, la « Charge Consumption » des lunettes : la contrainte que le réseau utilise au-delà de ce que donnent ses autres sources, partagée entre ses batteries qui se déchargent ; 0 quand elles suffisent. Sans autre charge, une batterie qui entraîne des tapis dépense quand même 1 SU par tick (configuration serveur batteryMinDischarge). Lisez-la pendant que la batterie se décharge : les lunettes ne la montrent qu'à ce moment-là.

Renvoie
number
les SU qu'elle prend sur sa charge à chaque tick

Comme la charge est en SU-heures, la charge divisée par la consommation donne le temps restant, en heures :

Brass
local bat = peripheral.find("kinetic_battery")
local conso = bat.consumption()
if bat.discharging() and conso > 0 then
  print(math.floor(bat.charge() / conso * 60) .. " minutes restantes")
end

Voir aussi kinetic_battery.charge()

#

bat.direction()

→ string

Le sens dans lequel la batterie tourne quand elle se décharge, celui de son panneau de réglage (« Direction de rotation pendant la décharge »).

Renvoie
string
"clockwise" (sens horaire) ou "counter_clockwise" (sens antihoraire)
Brass
print(bat.direction())

Voir aussi kinetic_battery.set_direction()

#

bat.set_direction(way)

Règle le panneau, à la fin du tick : une batterie qui se décharge tourne aussitôt dans l'autre sens. Un autre mot arrête le programme avec bad argument #1 to 'set_direction' ("clockwise" or "counter_clockwise").

Paramètres
way string
"clockwise" ou "counter_clockwise"
Brass
bat.set_direction("counter_clockwise")

Voir aussi kinetic_battery.direction()

Poignée de surcharge

La poignée de surcharge protège un réseau. Quand le réseau dont elle fait partie passe en surcharge, elle décompte son délai, puis se désaccouple : la rotation s'arrête de l'autre côté, et le reste du réseau tourne de nouveau. Si la surcharge disparaît pendant le décompte, elle reste accouplée. Une fois désaccouplée, elle le reste jusqu'à ce qu'on la réinitialise avec une clé, une impulsion de redstone ou reset(), et seulement quand son propre réseau n'est plus en surcharge. Tant qu'elle reçoit de la redstone, elle ne se désaccouple jamais.

#

embrayage.state()

→ string

Où en est la poignée. Un comparateur contre elle lit 0 quand elle est désaccouplée, 15 sinon.

Renvoie
string
"coupled" (accouplée), "uncoupling" (en décompte) ou "uncoupled" (désaccouplée)
Brass
local embrayage = peripheral.find("overstress_clutch")
print(embrayage.state())

Voir aussi overstress_clutch.countdown() overstress_clutch.reset()

#

embrayage.delay()

→ number

Le délai de son panneau de réglage (« Dé-coupler le délai » en jeu), en ticks (20 par seconde), de 1 à 72000 (une heure). Une poignée neuve attend 1 tick.

Renvoie
number
les ticks qu'elle attend avant de se désaccoupler
Brass
print(embrayage.delay() / 20 .. " secondes")

Voir aussi overstress_clutch.set_delay()

#

embrayage.set_delay(ticks)

Règle le délai, gardé entre 1 et 72000, à la fin du tick. N'importe quel nombre entier de ticks convient, là où le panneau compte en ticks, en secondes ou en minutes. Un délai plus court qu'un décompte en cours raccourcit aussi ce décompte. Un nombre à virgule arrête le programme avec bad argument #1 to 'set_delay' (number has no integer representation).

Paramètres
ticks number
le nouveau délai, un nombre entier de ticks
Brass
embrayage.set_delay(40) -- 2 secondes

Voir aussi overstress_clutch.delay()

#

embrayage.countdown()

→ number

Tant que l'état est "uncoupling", le nombre de ticks qui restent avant que la poignée se désaccouple ; 0 dans les deux autres états.

Renvoie
number
les ticks restants avant qu'elle se désaccouple, 0 hors décompte
Brass
if embrayage.state() == "uncoupling" then
  print("désaccouplement dans " .. embrayage.countdown() .. " ticks")
end

Voir aussi overstress_clutch.state()

#

embrayage.reset()

→ boolean

Réaccouple la poignée, comme une clé, à la fin du tick. Renvoie false, sans rien faire, quand elle n'était pas désaccouplée. Comme la clé, elle reste sans effet tant que le réseau de la poignée est encore en surcharge, et si la surcharge revient une fois accouplée, le décompte repart.

Renvoie
boolean
true quand la poignée était désaccouplée

Une poignée qui réessaie toute seule toutes les 30 secondes :

Brass
local embrayage = peripheral.find("overstress_clutch")
while true do
  if embrayage.reset() then
    print("poignée réinitialisée")
  end
  sleep(30)
end

Voir aussi overstress_clutch.state()

Embrayage centrifuge

L'embrayage centrifuge ne s'accouple qu'à la bonne vitesse. En mode "min" (la ligne « ≥ » de son panneau de réglage), il est accouplé tant que son entrée tourne à son seuil ou plus vite ; en mode "max" (la ligne « ≤ »), tant que son entrée tourne à son seuil ou moins vite. À l'arrêt, il est toujours désaccouplé, et il ne change pas tant que son réseau est en surcharge. Un embrayage neuf s'accouple à partir de 64 tr/min.

#

cc.coupled()

→ boolean

true tant que l'embrayage transmet sa rotation, false tant qu'il est désaccouplé.

Renvoie
boolean
true tant qu'il laisse passer la rotation
Brass
local cc = peripheral.find("centrifugal_clutch")
print(cc.coupled())

Voir aussi centrifugal_clutch.threshold()

#

cc.threshold()

→ number

La vitesse du panneau de réglage, en tr/min, quel que soit le mode.

Renvoie
number
son seuil de vitesse, de 1 à 256 tr/min
Brass
print(cc.threshold() .. " tr/min, mode " .. cc.mode())

Voir aussi centrifugal_clutch.mode() centrifugal_clutch.set_threshold()

#

cc.mode()

→ string

La ligne choisie sur le panneau : "min" est « Minimum Speed » (≥), "max" est « Maximum Speed » (≤).

Renvoie
string
"min" (accouplé au seuil et au-dessus) ou "max" (au seuil et en dessous)
Brass
print(cc.mode())

Voir aussi centrifugal_clutch.set_mode()

#

cc.set_threshold(rpm)

Règle le seuil, gardé entre 1 et 256, et garde le mode ; à la fin du tick. Un nombre à virgule arrête le programme avec bad argument #1 to 'set_threshold' (number has no integer representation).

Paramètres
rpm number
le nouveau seuil, un nombre entier de tr/min
Brass
cc.set_threshold(128)

Voir aussi centrifugal_clutch.threshold()

#

cc.set_mode(mode)

Change de mode et garde le seuil, à la fin du tick. Un autre mot arrête le programme avec bad argument #1 to 'set_mode' (min, max).

Paramètres
mode string
"min" ou "max"
Brass
cc.set_mode("max") -- seulement jusqu'au seuil : un limiteur de vitesse

Voir aussi centrifugal_clutch.mode()

Poignée à roue libre

La poignée à roue libre ne laisse passer la rotation que dans un sens : elle est accouplée tant que son entrée tourne dans le sens de son panneau de réglage, et désaccouplée quand elle tourne dans l'autre sens ou s'arrête. Elle ne change pas tant que son réseau est en surcharge.

#

fw.coupled()

→ boolean

true tant que l'entrée tourne dans le bon sens et que la poignée la transmet.

Renvoie
boolean
true tant qu'elle laisse passer la rotation
Brass
local fw = peripheral.find("freewheel_clutch")
print(fw.coupled())

Voir aussi freewheel_clutch.direction()

#

fw.direction()

→ string

Le sens de son panneau de réglage (« Direction de la rotation »).

Renvoie
string
"clockwise" ou "counter_clockwise", le sens qu'elle laisse passer
Brass
print(fw.direction())

Voir aussi freewheel_clutch.set_direction()

#

fw.set_direction(way)

Règle le panneau, à la fin du tick ; la poignée s'accouple ou se désaccouple aussitôt si son entrée tourne maintenant dans le bon ou le mauvais sens. Un autre mot arrête le programme avec bad argument #1 to 'set_direction' ("clockwise" or "counter_clockwise").

Paramètres
way string
"clockwise" ou "counter_clockwise"
Brass
fw.set_direction("clockwise")

Voir aussi freewheel_clutch.direction()

Générateur d'impulsion séquencé

Le générateur d'impulsion séquencé joue un petit programme de signaux de redstone. Il se pose au sol comme un répéteur : son entrée est à l'arrière, sa sortie à l'avant, et un signal sur l'un de ses côtés l'arrête aussitôt. Au repos, il attend ; quand le signal à son arrière monte (tout passage à une puissance au-dessus de 0), il joue son programme depuis la première instruction, puis remet sa sortie à 0 et attend l'impulsion suivante. Un comparateur lit l'étape où il en est.

Un joueur écrit le programme dans son écran (clic droit) ; un ordinateur le lit et le remplace. Un ordinateur le lance comme un joueur, par une impulsion à son arrière : rs.set sur la face qui touche son arrière, ou un récepteur de Liaison de redstone placé là.

Le programme est une liste de 1 à 7 instructions, chacune une table {type=, value=, signal=} : les trois colonnes de l'écran. Les durées sont en ticks (20 par seconde) ; l'entrée est le signal à l'arrière du générateur. La valeur par défaut est celle que l'écran donne à une nouvelle instruction.

typedans son écranvalue (défaut)signal (défaut)
outputSortiela durée, de 1 à 600 ticks (10)la puissance qu'il sort, de 0 à 15 (15)
transformTransform until changela formule, de 0 à 9, voir plus bas (2)la constante C, de 0 à 15 (15)
wait_forAttendre1 attend que l'entrée s'allume, 0 qu'elle s'éteigne (1)la puissance qu'il sort en attendant (0)
wait_for_minOutput until min signalattend que l'entrée monte à cette valeur ou plus, de 0 à 15 (8)idem (0)
wait_for_maxOutput until max signalattend que l'entrée descende à cette valeur ou moins, de 0 à 15 (7)idem (0)
wait_for_exactOutput until exact signalattend que l'entrée vaille exactement cette valeur, de 0 à 15 (7)idem (0)
loop_forBoucler pourcombien de fois les instructions au-dessus s'exécutent en tout, de 1 à 100 (3)aucun
loop_ifBoucler si1 revient en haut tant que l'entrée est allumée, 0 tant qu'elle est éteinte (1)aucun
loop_if_minLoop if min signalrevient en haut tant que l'entrée vaut cette valeur ou plus, de 0 à 15 (8)aucun
loop_if_maxLoop if max signalrevient en haut tant que l'entrée vaut cette valeur ou moins, de 0 à 15 (7)aucun
loop_if_exactLoop if exact signalrevient en haut tant que l'entrée vaut exactement cette valeur, de 0 à 15 (7)aucun
loopBoucleaucune : revient en haut, sans finaucun
endFinaucune : le programme se termine, sortie à 0aucun
  • Les instructions wait_for attendent un changement de l'entrée : une entrée déjà à la cible doit la quitter puis y revenir. Les boucles regardent l'entrée telle qu'elle est, et passent à l'instruction suivante quand elles ne bouclent pas.
  • « En haut », c'est la première instruction. loop et end ferment le programme : rien de ce qui les suit ne compte.
  • transform sort une formule de l'entrée I et de la constante C, gardée entre 0 et 15, jusqu'à ce que l'entrée change : 0 I+C, 1 I-C, 2 C-I, 3 I×C, 4 I÷C (division entière, 0 quand C vaut 0), 5 I&C, 6 I|C, 7 I^C (et, ou, ou exclusif, bit à bit), 8 I<<C, 9 I>>C (décalages, sur 4 bits).
#

gen.running()

→ boolean

true de l'impulsion qui lance le programme jusqu'à ce qu'il se termine ou soit arrêté.

Renvoie
boolean
true pendant que son programme tourne
Brass
local gen = peripheral.find("sequenced_pulse_generator")
print(gen.running(), gen.step())

Voir aussi sequenced_pulse_generator.step()

#

gen.output()

→ number

La puissance à son avant en ce moment : le signal de l'instruction en cours, 0 au repos.

Renvoie
number
le signal qu'il donne en ce moment, de 0 à 15
Brass
print(gen.output())

Voir aussi sequenced_pulse_generator.input()

#

gen.input()

→ number

La puissance qui arrive à son arrière : celle qui le lance, et celle que lisent les instructions wait_for, loop_if et transform.

Renvoie
number
le signal à son arrière, de 0 à 15
Brass
print(gen.input())

Voir aussi sequenced_pulse_generator.output()

#

gen.step()

→ number|nil

L'instruction qui s'exécute, comptée à partir de 1 comme les lignes de l'écran et la liste de instructions() ; nil tant que le générateur attend une impulsion.

Renvoie
number|nil
l'instruction en cours, à partir de 1 ; nil au repos
Brass
local etape = gen.step()
if etape then
  print("étape " .. etape .. " : " .. gen.instructions()[etape].type)
end

Voir aussi sequenced_pulse_generator.instructions()

#

gen.instructions()

→ table

Le programme, tel que le montre son écran, avec son end. value manque pour loop et end, et signal pour les boucles et end, qui n'en ont pas.

Renvoie
table
son programme, un {type=, value=, signal=} par instruction
Brass
for i, ins in ipairs(gen.instructions()) do
  print(i, ins.type, ins.value, ins.signal)
end

Voir aussi sequenced_pulse_generator.set_instructions()

#

gen.set_instructions(list)

Remplace le programme et arrête le générateur, à la fin du tick : sa sortie passe à 0, et le nouveau programme attend la prochaine impulsion à son arrière. La liste est vérifiée comme l'écran la vérifie :

Paramètres
list table
de 1 à 7 instructions, chacune {type=, value=, signal=}
  • de 1 à 7 entrées, sinon bad argument #1 to 'set_instructions' (1 to 7 instructions) ;
  • chaque entrée est une table avec un type connu (en minuscules), sinon bad instruction #2 to 'set_instructions' (...), le texte entre parenthèses disant ce qui ne va pas ;
  • value et signal sont arrondis à l'entier et gardés dans leurs bornes (le tableau plus haut) ; s'il en manque un, il prend sa valeur par défaut, et celui dont le type ne se sert pas est ignoré ;
  • rien de ce qui suit le premier end ou loop n'est gardé ;
  • un end est ajouté après la dernière instruction quand il reste de la place (moins de 7), comme le fait l'écran.

Une lampe qui clignote, une seconde allumée, une seconde éteinte, jusqu'à ce qu'un signal sur un côté du générateur l'arrête. Le générateur est à droite de l'ordinateur, l'arrière contre lui :

Brass
local gen = peripheral.wrap("right")
gen.set_instructions({
  {type = "output", value = 20, signal = 15},
  {type = "output", value = 20, signal = 0},
  {type = "loop"},
})
sleep(0.1)              -- le nouveau programme est en place
rs.set("right", true)   -- une impulsion à son arrière le lance
sleep(0.1)
rs.set("right", false)

Voir aussi sequenced_pulse_generator.instructions() sequenced_pulse_generator.stop()

#

gen.stop()

Arrête le programme et met la sortie à 0, comme un signal sur l'un de ses côtés, à la fin du tick. Le programme reste ; la prochaine impulsion à son arrière le rejoue depuis le début.

Brass
gen.stop()

Voir aussi sequenced_pulse_generator.running()

Tableau de bord

Le tableau de bord (Dashboard, pas traduit en jeu) est un petit écran de 4 lignes. Son texte s'affiche sur le bloc, et dans la ligne de messages au-dessus de la barre d'objets d'un joueur assis juste devant lui, sur un siège par exemple : les lignes non vides, côte à côte, dans sa couleur. Plusieurs tableaux de bord autour du même siège s'affichent chacun leur tour, toutes les 2 secondes. Une clé coupe cet envoi au joueur et le rétablit ; le bloc continue d'afficher son texte. Les joueurs y écrivent avec un presse-papiers, une étiquette ou une Liaison d'affichage, le teignent, et le vident d'un clic à main nue : un ordinateur l'écrit, le colore et le vide depuis un programme.

#

dash.lines()

→ table

Le texte des 4 lignes, quel que soit son auteur (un joueur, une Liaison d'affichage, un ordinateur).

Renvoie
table
ses 4 lignes de texte, "" pour une ligne vide
Brass
local dash = peripheral.find("dashboard")
for i, ligne in ipairs(dash.lines()) do
  print(i, ligne)
end

Voir aussi dashboard.set_line()

#

dash.set_line(n, text)

Écrit une ligne, à la fin du tick ; les trois autres restent. Un texte de plus de 64 caractères est coupé. Le bloc lui-même affiche environ 15 caractères par ligne, la ligne de messages la ligne entière. Un autre numéro de ligne arrête le programme avec bad argument #1 to 'set_line' (line 1 to 4). Pour vider une seule ligne, écrivez "".

Paramètres
n number
la ligne, de 1 à 4
text string
ce qu'il faut écrire (un nombre s'écrit comme l'écrit tostring)

Une Liaison d'affichage tournée vers le tableau de bord écrit aussi ses lignes : le dernier qui écrit l'emporte.

Brass
dash.set_line(1, "Vitesse : 64 tr/min")

Voir aussi dashboard.lines() dashboard.clear()

#

dash.clear()

Vide les 4 lignes, comme un clic à main nue, à la fin du tick.

Brass
dash.clear()

Voir aussi dashboard.set_line()

#

dash.color()

→ string

La teinture du texte, comme "white" (un tableau de bord neuf) ou "light_blue".

Renvoie
string
la couleur de son texte, un nom de teinture
Brass
print(dash.color())

Voir aussi dashboard.set_color()

#

dash.set_color(color)

Teint le texte, à la fin du tick, sur le bloc et dans la ligne de messages. "grey" vaut "gray" ; un autre mot arrête le programme avec une erreur qui donne les 16 noms. Un texte lumineux le reste.

Paramètres
color string
un nom de teinture : white, orange, magenta, light_blue, yellow, lime, pink, gray, light_gray, cyan, purple, blue, brown, green, red, black
Brass
dash.set_color("lime")

Voir aussi dashboard.color()

#

dash.open()

→ boolean

true tant que le tableau de bord envoie son texte au joueur assis devant lui ; false une fois qu'une clé a coupé cet envoi. Le bloc affiche son texte dans les deux cas, et un programme l'écrit dans les deux cas.

Renvoie
boolean
true tant qu'il envoie son texte au joueur assis devant lui
Brass
if not dash.open() then
  print("le tableau de bord est coupé : utilisez une clé dessus")
end

Voir aussi dashboard.lines()

Leviers et boutons liés

Un transmetteur lié (un objet de Create: Connected) utilisé sur un levier, un bouton ou un levier analogique en fait un bloc lié : il marche comme avant et alimente les blocs autour de lui, et il émet en plus son signal sur une fréquence de Liaison de redstone, fixée par les deux objets de ses emplacements, vers les récepteurs à portée (voir Liaison de redstone). Avec Create Simulated (livré avec Create Aeronautics), le transmetteur va aussi sur son levier d'accélération (Throttle Lever). Une clé retire le transmetteur : le bloc redevient un bloc ordinaire, et un appel arrête le programme avec linked lever removed.

Un ordinateur actionne ces blocs comme un joueur, si bien que les récepteurs suivent, et lit leur fréquence, pour l'écouter avec link. Pour émettre sans aucun bloc, link.set suffit : un levier lié sert pour une fréquence qu'un joueur actionne aussi à la main.

#

levier.frequency()

→ table

La fréquence sur laquelle il émet, en identifiants d'objets ; "minecraft:air" pour un emplacement vide. Les quatre blocs liés l'ont.

Renvoie
table
{a=, b=}, les identifiants des objets de ses deux emplacements de fréquence
Brass
local levier = peripheral.find("linked_lever")
local f = levier.frequency()
print(f.a, f.b)
print("sur les ondes : " .. link.get(f.a, f.b))

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

#

levier.powered()

→ boolean

true tant que le levier est activé, et émet 15. Levier lié seulement.

Renvoie
boolean
true tant que le levier est activé
Brass
print(levier.powered())

Voir aussi linked_transmitter.set_powered()

#

levier.set_powered(on)

Actionne le levier comme un joueur, à la fin du tick, quand il n'est pas déjà dans cette position : il claque, alimente les blocs autour de lui et émet. Levier lié seulement. Autre chose qu'un booléen arrête le programme avec bad argument #1 to 'set_powered' (boolean expected, got number).

Paramètres
on boolean
true pour activer le levier, false pour le désactiver
Brass
levier.set_powered(true)

Voir aussi linked_transmitter.powered()

#

bouton.pressed()

→ boolean

true tant que le bouton est enfoncé, et émet 15. Bouton lié seulement.

Renvoie
boolean
true tant que le bouton est enfoncé
Brass
local bouton = peripheral.find("linked_button")
print(bouton.pressed())

Voir aussi linked_transmitter.press()

#

bouton.press()

→ boolean

Enfonce le bouton comme un joueur, à la fin du tick : il émet jusqu'à ce qu'il ressorte, au bout d'une seconde pour un bouton de pierre et d'une seconde et demie pour un bouton de bois. Renvoie false, sans rien faire, tant que le bouton est déjà enfoncé. Bouton lié seulement.

Renvoie
boolean
true quand il a enfoncé le bouton, false quand le bouton l'était déjà
Brass
bouton.press()

Voir aussi linked_transmitter.pressed()

#

levier.signal()

→ number

La position du levier, de 0 à 15 : le signal qu'il donne et émet. Levier analogique lié et levier d'accélération lié.

Renvoie
number
le signal du levier, de 0 à 15
Brass
local levier = peripheral.find("linked_analog_lever")
print(levier.signal())

Voir aussi linked_transmitter.set_signal()

#

levier.set_signal(power)

Amène le levier sur ce signal, gardé entre 0 et 15, à la fin du tick. Levier analogique lié et levier d'accélération lié. Un levier analogique tourne cran par cran, comme sous la main d'un joueur : signal() donne aussitôt la nouvelle position, mais sa sortie et ce qu'il émet suivent 15 ticks (0,75 s) après le dernier cran. Un levier d'accélération émet le nouveau signal aussitôt, et donne le signal demandé même quand une clé l'a inversé.

Paramètres
power number
le signal voulu, un nombre entier de 0 à 15
Brass
levier.set_signal(8)

Voir aussi linked_transmitter.signal()

Pont cinétique

Le pont cinétique fait passer de la puissance d'un réseau à un autre en les gardant séparés. Il fait deux blocs : la moitié qui porte le panneau de réglage prend la rotation et c'est elle le périphérique ; elle est une charge de impact × tr/min SU pour son réseau. L'autre moitié tourne à la même vitesse et donne autant de capacité au second réseau, si bien qu'une surcharge de ce côté n'arrête pas le premier réseau. Quand le premier réseau est en surcharge, le pont ne transmet rien. Le panneau, « Impact du stress par RPM », va de 1 à 65536 en 160 crans, chacun environ 7 % au-dessus du précédent ; un pont neuf prend 16. L'autre moitié n'est qu'un bloc Blocs cinétiques de Create.

#

pont.stress_impact()

→ number

Le panneau de réglage, en SU par tr/min, arrondi à 3 décimales : sous 16 les crans ont des décimales (1.072, 1.149...), à partir de 16 ce sont des nombres entiers.

Renvoie
number
les SU par tr/min qu'il prend, et rend à l'autre bout
Brass
local pont = peripheral.find("kinetic_bridge")
print(pont.stress_impact() * math.abs(pont.speed()) .. " SU transmises")

Voir aussi kinetic_bridge.set_stress_impact()

#

pont.set_stress_impact(su)

→ number

Prend le cran du panneau le plus proche, entre 1 et 65536, à la fin du tick, et le renvoie aussitôt.

Paramètres
su number
les SU par tr/min voulues
Renvoie
number
l'impact retenu, un cran du panneau
Brass
print(pont.set_stress_impact(16))
print(pont.set_stress_impact(100))
print(pont.set_stress_impact(1000))

Ceci affiche 16, puis 97 et 1024, les crans les plus proches de 100 et de 1000.

Voir aussi kinetic_bridge.stress_impact()

Une batterie avec une réserve

Une batterie cinétique à gauche de l'ordinateur, un levier derrière lui, un tableau de bord devant un siège, sur le Câble de données de l'ordinateur. Le levier demande l'énergie de la batterie ; l'ordinateur donne la redstone à la batterie, mais garde une réserve : sous 10 %, il arrête la décharge, et ne la permet de nouveau qu'à partir de 25 %. Le tableau de bord montre la charge, l'état et le temps restant au joueur assis.

Brass
local bat = peripheral.wrap("left")
local dash = peripheral.find("dashboard")
local BAS, HAUT = 0.10, 0.25
local ETATS = {charging = "en charge", discharging = "en décharge", full = "pleine", empty = "vide"}
local reserve = false

while true do
  local part = bat.charge() / bat.max_charge()
  if part <= BAS then
    reserve = true
  elseif part >= HAUT then
    reserve = false
  end
  local demande = rs.get("back") > 0
  rs.set("left", demande and not reserve)

  dash.set_line(1, "Batterie " .. math.floor(part * 100) .. " %")
  dash.set_line(2, ETATS[bat.status()])
  local conso = bat.consumption()
  if bat.discharging() and conso > 0 then
    dash.set_line(3, "reste " .. math.floor(bat.charge() / conso * 60) .. " min")
  else
    dash.set_line(3, "")
  end
  if demande and reserve then
    dash.set_line(4, "Réserve !")
  else
    dash.set_line(4, "")
  end
  dash.set_color(reserve and "red" or "lime")
  sleep(1)
end