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.
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érique | ce qu'il lit ou règle |
|---|---|---|
| Batterie cinétique | kinetic_battery | sa charge en SU-heures, et son sens de rotation quand elle se décharge |
| Poignée de surcharge | overstress_clutch | son état et son délai ; la réaccouple comme une clé |
| Embrayage centrifuge | centrifugal_clutch | s'il est accouplé, son seuil de vitesse et son mode |
| Poignée à roue libre | freewheel_clutch | si elle est accouplée, et le sens qu'elle laisse passer |
| Générateur d'impulsion séquencé | sequenced_pulse_generator | son programme, l'étape en cours, son entrée et sa sortie |
| tableau de bord (Dashboard) | dashboard | ses 4 lignes de texte et leur couleur |
| Levier lié | linked_lever | sa fréquence et sa position ; l'actionne |
| Bouton lié (de tout bois ou pierre) | linked_button | sa fréquence ; l'enfonce |
| Levier analogique lié | linked_analog_lever | sa fréquence et son signal ; le tourne |
| levier d'accélération lié (Linked Throttle Lever, avec Create Simulated) | linked_throttle_lever | sa fréquence et son signal ; le déplace |
| Pont cinétique | kinetic_bridge | la 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.
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 :
| erreur | quand |
|---|---|
kinetic battery removed | le bloc a été cassé ou remplacé depuis peripheral.wrap (son type, avec des espaces) |
peripheral is not loaded | le 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 getBatteryLevel | votre 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.
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()
Ce que contient la batterie, en SU-heures, arrondi à 3 décimales : le premier nombre que montrent les Lunettes d'ingénieur sous « Charge ».
- number
- la charge qu'elle contient, en SU-heures
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()
La capacité d'une batterie, en SU-heures : 512, sauf si le serveur a changé batteryCapacity. Toutes les batteries ont la même.
- number
- la charge qu'elle peut contenir au plus, en SU-heures
local bat = peripheral.find("kinetic_battery")
print(math.floor(bat.charge() / bat.max_charge() * 100) .. " %")Voir aussi kinetic_battery.charge()
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.
- boolean
- true tant que la redstone la fait se décharger
local bat = peripheral.find("kinetic_battery")
if bat.discharging() then
print("Sur batterie")
endVoir aussi kinetic_battery.status()
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.
- string
- "charging", "discharging", "full" ou "empty"
local bat = peripheral.wrap("left")
if bat.status() == "empty" then
rs.set("left", false) -- retour en charge
endVoir aussi kinetic_battery.discharging()
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à.
- 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 :
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")
endVoir aussi kinetic_battery.charge()
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 »).
- string
- "clockwise" (sens horaire) ou "counter_clockwise" (sens antihoraire)
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").
waystring- "clockwise" ou "counter_clockwise"
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()
Où en est la poignée. Un comparateur contre elle lit 0 quand elle est désaccouplée, 15 sinon.
- string
- "coupled" (accouplée), "uncoupling" (en décompte) ou "uncoupled" (désaccouplée)
local embrayage = peripheral.find("overstress_clutch")
print(embrayage.state())Voir aussi overstress_clutch.countdown() overstress_clutch.reset()
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.
- number
- les ticks qu'elle attend avant de se désaccoupler
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).
ticksnumber- le nouveau délai, un nombre entier de ticks
embrayage.set_delay(40) -- 2 secondesVoir aussi overstress_clutch.delay()
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.
- number
- les ticks restants avant qu'elle se désaccouple, 0 hors décompte
if embrayage.state() == "uncoupling" then
print("désaccouplement dans " .. embrayage.countdown() .. " ticks")
endVoir aussi overstress_clutch.state()
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.
- boolean
- true quand la poignée était désaccouplée
Une poignée qui réessaie toute seule toutes les 30 secondes :
local embrayage = peripheral.find("overstress_clutch")
while true do
if embrayage.reset() then
print("poignée réinitialisée")
end
sleep(30)
endVoir 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()
true tant que l'embrayage transmet sa rotation, false tant qu'il est désaccouplé.
- boolean
- true tant qu'il laisse passer la rotation
local cc = peripheral.find("centrifugal_clutch")
print(cc.coupled())Voir aussi centrifugal_clutch.threshold()
cc.threshold()
La vitesse du panneau de réglage, en tr/min, quel que soit le mode.
- number
- son seuil de vitesse, de 1 à 256 tr/min
print(cc.threshold() .. " tr/min, mode " .. cc.mode())Voir aussi centrifugal_clutch.mode() centrifugal_clutch.set_threshold()
cc.mode()
La ligne choisie sur le panneau : "min" est « Minimum Speed » (≥), "max" est « Maximum Speed » (≤).
- string
- "min" (accouplé au seuil et au-dessus) ou "max" (au seuil et en dessous)
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).
rpmnumber- le nouveau seuil, un nombre entier de tr/min
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).
modestring- "min" ou "max"
cc.set_mode("max") -- seulement jusqu'au seuil : un limiteur de vitesseVoir 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()
true tant que l'entrée tourne dans le bon sens et que la poignée la transmet.
- boolean
- true tant qu'elle laisse passer la rotation
local fw = peripheral.find("freewheel_clutch")
print(fw.coupled())Voir aussi freewheel_clutch.direction()
fw.direction()
Le sens de son panneau de réglage (« Direction de la rotation »).
- string
- "clockwise" ou "counter_clockwise", le sens qu'elle laisse passer
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").
waystring- "clockwise" ou "counter_clockwise"
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.
type | dans son écran | value (défaut) | signal (défaut) |
|---|---|---|---|
output | Sortie | la durée, de 1 à 600 ticks (10) | la puissance qu'il sort, de 0 à 15 (15) |
transform | Transform until change | la formule, de 0 à 9, voir plus bas (2) | la constante C, de 0 à 15 (15) |
wait_for | Attendre | 1 attend que l'entrée s'allume, 0 qu'elle s'éteigne (1) | la puissance qu'il sort en attendant (0) |
wait_for_min | Output until min signal | attend que l'entrée monte à cette valeur ou plus, de 0 à 15 (8) | idem (0) |
wait_for_max | Output until max signal | attend que l'entrée descende à cette valeur ou moins, de 0 à 15 (7) | idem (0) |
wait_for_exact | Output until exact signal | attend que l'entrée vaille exactement cette valeur, de 0 à 15 (7) | idem (0) |
loop_for | Boucler pour | combien de fois les instructions au-dessus s'exécutent en tout, de 1 à 100 (3) | aucun |
loop_if | Boucler si | 1 revient en haut tant que l'entrée est allumée, 0 tant qu'elle est éteinte (1) | aucun |
loop_if_min | Loop if min signal | revient en haut tant que l'entrée vaut cette valeur ou plus, de 0 à 15 (8) | aucun |
loop_if_max | Loop if max signal | revient en haut tant que l'entrée vaut cette valeur ou moins, de 0 à 15 (7) | aucun |
loop_if_exact | Loop if exact signal | revient en haut tant que l'entrée vaut exactement cette valeur, de 0 à 15 (7) | aucun |
loop | Boucle | aucune : revient en haut, sans fin | aucun |
end | Fin | aucune : le programme se termine, sortie à 0 | aucun |
- Les instructions
wait_forattendent 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.
loopetendferment le programme : rien de ce qui les suit ne compte. transformsort 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 : 0I+C, 1I-C, 2C-I, 3I×C, 4I÷C(division entière, 0 quand C vaut 0), 5I&C, 6I|C, 7I^C(et, ou, ou exclusif, bit à bit), 8I<<C, 9I>>C(décalages, sur 4 bits).
gen.running()
true de l'impulsion qui lance le programme jusqu'à ce qu'il se termine ou soit arrêté.
- boolean
- true pendant que son programme tourne
local gen = peripheral.find("sequenced_pulse_generator")
print(gen.running(), gen.step())Voir aussi sequenced_pulse_generator.step()
gen.output()
La puissance à son avant en ce moment : le signal de l'instruction en cours, 0 au repos.
- number
- le signal qu'il donne en ce moment, de 0 à 15
print(gen.output())Voir aussi sequenced_pulse_generator.input()
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.
- number
- le signal à son arrière, de 0 à 15
print(gen.input())Voir aussi sequenced_pulse_generator.output()
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.
- number|nil
- l'instruction en cours, à partir de 1 ; nil au repos
local etape = gen.step()
if etape then
print("étape " .. etape .. " : " .. gen.instructions()[etape].type)
endVoir aussi sequenced_pulse_generator.instructions()
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.
- table
- son programme, un {type=, value=, signal=} par instruction
for i, ins in ipairs(gen.instructions()) do
print(i, ins.type, ins.value, ins.signal)
endVoir aussi sequenced_pulse_generator.set_instructions()
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 :
listtable- 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
typeconnu (en minuscules), sinonbad instruction #2 to 'set_instructions' (...), le texte entre parenthèses disant ce qui ne va pas ; valueetsignalsont 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
endouloopn'est gardé ; - un
endest 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 :
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.
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()
Le texte des 4 lignes, quel que soit son auteur (un joueur, une Liaison d'affichage, un ordinateur).
- table
- ses 4 lignes de texte, "" pour une ligne vide
local dash = peripheral.find("dashboard")
for i, ligne in ipairs(dash.lines()) do
print(i, ligne)
endVoir 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 "".
nnumber- la ligne, de 1 à 4
textstring- 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.
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.
dash.clear()Voir aussi dashboard.set_line()
dash.color()
La teinture du texte, comme "white" (un tableau de bord neuf) ou "light_blue".
- string
- la couleur de son texte, un nom de teinture
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.
colorstring- un nom de teinture : white, orange, magenta, light_blue, yellow, lime, pink, gray, light_gray, cyan, purple, blue, brown, green, red, black
dash.set_color("lime")Voir aussi dashboard.color()
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.
- boolean
- true tant qu'il envoie son texte au joueur assis devant lui
if not dash.open() then
print("le tableau de bord est coupé : utilisez une clé dessus")
endVoir 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()
La fréquence sur laquelle il émet, en identifiants d'objets ; "minecraft:air" pour un emplacement vide. Les quatre blocs liés l'ont.
- table
- {a=, b=}, les identifiants des objets de ses deux emplacements de fréquence
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()
true tant que le levier est activé, et émet 15. Levier lié seulement.
- boolean
- true tant que le levier est activé
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).
onboolean- true pour activer le levier, false pour le désactiver
levier.set_powered(true)Voir aussi linked_transmitter.powered()
bouton.pressed()
true tant que le bouton est enfoncé, et émet 15. Bouton lié seulement.
- boolean
- true tant que le bouton est enfoncé
local bouton = peripheral.find("linked_button")
print(bouton.pressed())Voir aussi linked_transmitter.press()
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.
- boolean
- true quand il a enfoncé le bouton, false quand le bouton l'était déjà
bouton.press()Voir aussi linked_transmitter.pressed()
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é.
- number
- le signal du levier, de 0 à 15
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é.
powernumber- le signal voulu, un nombre entier de 0 à 15
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()
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.
- number
- les SU par tr/min qu'il prend, et rend à l'autre bout
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)
Prend le cran du panneau le plus proche, entre 1 et 65536, à la fin du tick, et le renvoie aussitôt.
sunumber- les SU par tr/min voulues
- number
- l'impact retenu, un cran du panneau
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.
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