Create: Computing AgesDoc Brass
Périphériques

Blocs de Create Aeronautics

Levier d'accélération, lasers, minuteries de redstone, assembleur physique, treuil, ressorts, volant, moteur, canon, roues et foreuse de Create Aeronautics, lus et pilotés par un ordinateur.

Il faut Create Aeronautics

Ces blocs viennent avec Create Aeronautics ; la plupart appartiennent à Create Simulated et Offroad, deux mods qu'il embarque. Sans lui, ces blocs n'existent pas, et peripheral.find("steering_wheel") renvoie nil.

En plus de ses capteurs et de ses moteurs, Create Aeronautics apporte les blocs qui construisent, relient et dirigent ses véhicules : un levier d'accélération et un volant, des lasers, des minuteries de redstone, l'assembleur physique qui fait d'une construction un véhicule, des cordes et des ressorts, des roues, un moteur, un canon et une foreuse. Un ordinateur lit chacun d'eux exactement, et pilote ce qu'un joueur piloterait : il règle un levier ou un volant sur une valeur précise, assemble un véhicule, change la longueur d'un ressort. De quoi faire un pilote automatique, un fil piège laser, une grue qui s'arrête à la bonne longueur ou une foreuse qui sait qu'elle est pleine.

Create Aeronautics et ses deux mods ne sont pas traduits en français : en jeu, les blocs gardent leur nom anglais, indiqué entre parenthèses.

Bloc (nom en jeu)type de périphériquece qu'il lit ou règle
levier d'accélération (Throttle Lever)throttle_leverson signal de redstone, qu'il peut régler
pointeur laser (Laser Pointer)laser_pointerson faisceau : puissance, longueur, couleur, ce qu'il touche
capteur laser (Laser Sensor)laser_sensorle faisceau qu'il reçoit, et la distance de son pointeur
accumulateur de redstone (Redstone Accumulator)redstone_accumulatorson compte, qu'il peut régler, et son délai
inducteur de redstone (Redstone Inductor)redstone_inductorsa sortie et son délai
assembleur physique (Physics Assembler)physics_assemblerassemble un véhicule et le défait
treuil (Rope Winch)rope_winchla longueur de sa corde et sa vitesse d'enroulement
ressort (Spring)springla longueur qu'il tient, qu'il peut changer
volant (Steering Wheel)steering_wheelson angle, qu'il peut régler
transmission analogique (Analog Transmission)analog_transmissionla vitesse de sa roue dentée
moteur portable (Portable Engine)portable_engineson combustible et son sens de rotation
canon à pomme de terre monté (Mounted Potato Cannon)mounted_potato_cannonsa charge et ses munitions
support de roue (Wheel Mount)wheel_mountsa suspension, son braquage et son pneu
roulement de tête de forage (Borehead Bearing)borehead_bearings'il creuse ; l'assemble et l'arrête

Les capteurs, les brûleurs et les hélices ont leur propre page : Capteurs de Create Aeronautics, Brûleur à air chaud et Hélices.

Atteindre un bloc. Contre l'ordinateur, un bloc s'appelle par sa face ("left", "top"...) ; sur un Câble de données (Mini-ordinateur et plus récents), il reçoit un nom comme steering_wheel@12,64,-30. peripheral.find en cherche un par son type. Un ordinateur atteint les blocs d'un véhicule depuis le bord : collez-le au véhicule, souvent sous forme de Microcontrôleur.

Brass
local levier = peripheral.find("throttle_lever")
local volant = peripheral.find("steering_wheel")
print("gaz " .. levier.signal() .. ", volant à " .. volant.angle() .. " degrés")

Toutes les mesures d'un coup. Comme les capteurs, chaque bloc de cette page a un read() (voir sensor.read()) : un seul appel renvoie une table de toutes ses mesures, sous les noms des méthodes qui ne font que lire (toutes les méthodes ci-dessous sans set_ dans leur nom, sauf assemble et disassemble). Un pointeur laser donne power, on, range, color et distance ; une mesure qui vaut nil est absente de la table.

Ce qui revient. Les nombres sont arrondis à 3 décimales, et chaque appel relit le bloc. Un changement (set_..., assemble, disassemble) se fait à la fin du tick du programme, comme le ferait le clic d'un joueur, sauf si la méthode dit autre chose : une lecture dans le même tick donne encore l'ancienne valeur. Quand quelque chose ne va pas, l'appel arrête le programme avec une erreur que vous pouvez rattraper avec pcall :

erreurquand
steering wheel 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_signal' (number has no integer representation)un mauvais argument : ici 7.5 là où il faut un nombre entier
this version of Create Aeronautics has no getStatevotre version du mod n'a pas ce que lit la méthode (le nom à la fin est celui qui manque)
Create Aeronautics error: ...le bloc lui-même a échoué en répondant

Aussi des blocs cinétiques et des inventaires. Les blocs qui tournent (treuil, volant, transmission analogique, moteur portable, canon à pomme de terre monté, support de roue, roulement de tête de forage) ont en plus les méthodes de Blocs cinétiques de Create, comme speed(), la vitesse de leur arbre. Le moteur portable (son combustible), le canon (ses munitions), le support de roue (son pneu) et le roulement de tête de forage (le stockage de sa foreuse, tant qu'elle est assemblée) ont aussi celles de Inventaires. Aucune méthode de cette page n'en cache une : sur la transmission analogique, speed() est la vitesse de l'arbre et analog_transmission.cog_speed() celle de la roue dentée.

Méthodes
levier.signal()Le signal que donne le levier en ce moment, de 0 à 15, qu'il soit inversé ou non.
levier.set_signal(power)Place le levier, avec son clic, sur la position qui donne ce signal (un levier inversé prend lui aussi la position qui le donne). Le levier bouge à la fin du tick, et les blocs qu'il alimente voient le nouveau signal deux ticks plus tard. Ne renvoie rien. Les valeurs hors de 0 à 15 sont ramenées dans l'intervalle ; un nombre à virgule arrête le programme (arrondissez-le avec math.floor).
levier.inverted()true quand une Clé a inversé le levier : ses positions comptent dans l'autre sens, et celle qui donnait 3 donne maintenant 12. signal et set_signal en tiennent déjà compte.
laser.power()Le signal de redstone le plus fort autour du pointeur, de 0 (éteint) à 15 ; sur un pointeur inversé, 15 moins ce signal. C'est aussi la puissance que reçoit un capteur laser de son faisceau.
laser.on()true tant que le pointeur projette son faisceau, c'est-à-dire tant que sa puissance est au-dessus de 0.
laser.range()La longueur réglée sur le panneau du pointeur (« Max Casting Distance »), en blocs : de 1 au maximum du serveur (100 par défaut, configuration serveur laser_pointer_max_range). Un pointeur neuf commence au maximum.
laser.set_range(blocks)Règle la longueur du faisceau, comme si l'on tournait le panneau, et renvoie la valeur retenue. Contrairement à la plupart des changements, elle s'applique tout de suite.
laser.color()La couleur du faisceau : le nom de la teinture qui l'a donnée ("red", "light_blue"...), "amethyst" (la couleur d'un pointeur neuf) ou "rainbow" (arc-en-ciel).
laser.set_color(color)Donne une couleur au faisceau, comme une teinture, un Éclat d'améthyste ou une Étoile du Nether utilisés sur le pointeur. Les noms de teinture sont ceux de Minecraft, en anglais : white, orange, magenta, light_blue, yellow, lime, pink, gray, light_gray, cyan, purple, blue, brown, green, red, black (grey marche aussi). Tout autre nom arrête le programme avec une erreur qui les liste. S'applique à la fin du tick ; ne renvoie rien.
laser.distance()Jusqu'où va le faisceau avant qu'un bloc l'arrête, en blocs, depuis l'avant du pointeur. nil tant que le pointeur est éteint, ou quand le faisceau va jusqu'au bout sans rencontrer de bloc. Les joueurs et les mobs ne comptent pas, seulement les blocs.
capteur.power()La puissance du faisceau le plus fort qui atteint l'avant du capteur et passe son filtre, de 0 (aucun) à 15 : le signal de redstone que donne le capteur.
capteur.distance()La distance du pointeur le plus proche dont le faisceau atteint le capteur, en blocs, de l'avant de ce pointeur jusqu'au point où son faisceau touche le capteur. nil tant qu'aucun faisceau ne l'atteint.
capteur.filter()L'objet dans le filtre du capteur, sous forme d'id : une teinture ("minecraft:red_dye"), un Éclat d'améthyste ("minecraft:amethyst_shard") ou une Étoile du Nether ("minecraft:nether_star"). nil quand le filtre est vide : le capteur voit alors tous les faisceaux. Avec une teinture ou un éclat, il ne voit que les faisceaux de cette couleur ; avec une Étoile du Nether, seulement les faisceaux arc-en-ciel, qui à leur tour n'allument aucun capteur filtré par une teinture ou un éclat.
acc.count()Le compte que garde l'accumulateur, de 0 à 15 : ce qu'il donne tant qu'il n'est pas inversé.
acc.output()Le signal que donne l'accumulateur par l'avant : son compte, ou 15 moins son compte quand il est inversé.
acc.set_count(n)Règle le compte, ramené entre 0 et 15, à la fin du tick ; l'accumulateur continue de compter à partir de là. Ne renvoie rien. Une minuterie que l'ordinateur remet à zéro :
acc.delay()Combien de ticks l'accumulateur attend entre deux crans, de 2 à 72000.
acc.set_delay(ticks)Règle le délai, comme le panneau, à la fin du tick, et renvoie la valeur retenue.
acc.inverted()true quand un clic a inversé l'accumulateur : il donne 15 moins son compte.
ind.output()Le signal que donne l'inducteur par l'avant, de 0 à 15, qu'il soit inversé ou non.
ind.delay()Combien de ticks l'inducteur attend entre deux crans, de 0 (il copie son entrée) à 72000.
ind.set_delay(ticks)Règle le délai, comme le panneau, à la fin du tick, et renvoie la valeur retenue.
ind.inverted()true quand un clic a inversé l'inducteur : il donne 15 moins le signal qu'il a atteint.
pa.assembled()true tant que l'assembleur est sur un véhicule physique, celui qu'il a assemblé ou un autre.
pa.disassembling()true après un disassemble() (ou un coup de levier) pendant que le véhicule tourne et se déplace pour s'aligner sur la grille des blocs, avant de poser ses blocs.
pa.error()La raison que donne le mod pour le dernier refus, en anglais, comme "Moving too fast to disassemble!". nil quand rien n'a échoué (un assemblage réussi l'efface). Aux réglages par défaut, un véhicule n'est pas défait tant qu'il va plus vite que 5 blocs par seconde, loin de tout sol, hors de la hauteur du monde, ou quand il n'arrive pas à s'aligner en 5 secondes.
pa.assemble()Fait du bloc auquel l'assembleur est collé, et de tout ce qui est collé à lui, un véhicule, comme un coup de son levier. L'assemblage a lieu à la fin du tick ; quand il échoue, physics_assembler.error() dit pourquoi.
pa.disassemble()Remet le véhicule en blocs, comme un coup de levier sur un véhicule. À la fin du tick, le véhicule commence à s'aligner (physics_assembler.disassembling() vaut alors true), et pose ses blocs une fois en place. Un refus laisse le véhicule tel quel, avec la raison dans physics_assembler.error(). Pour un ordinateur à bord :
treuil.attached()true tant qu'une corde est attachée au treuil.
treuil.length()La longueur de la corde en ce moment, en blocs, mesurée le long de la corde. nil sans corde.
treuil.max_length()La longueur maximale jusqu'à laquelle le treuil déroule sa corde, en blocs : 40 par défaut (configuration serveur max_rope_range).
treuil.reel_speed()La vitesse à laquelle l'arbre fait dérouler la corde au treuil, en blocs par seconde : les tr/min divisés par 25,6, au plus 9,8. Négative quand il enroule, 0 à l'arrêt. C'est ce que demande l'arbre : une corde tendue ne rentre pas, et une corde à sa longueur maximale ne sort plus.
treuil.stretched()true tant que la charge tire la corde de plus de 25 % au-delà de sa longueur : le treuil refuse alors d'enrouler. Allégez la charge, ou déroulez un peu de corde.
ressort.length()La longueur vers laquelle la paire tire ou pousse, en blocs, de 1 à 9 par quarts. Les deux ressorts d'une paire lisent la même.
ressort.distance()L'écart entre les deux ressorts de la paire en ce moment, en blocs, de centre à centre, où que soient leurs véhicules. Comparé à spring.length(), il dit si le ressort est étiré ou comprimé.
ressort.size()La taille du ressort, que change une Clé : "small" (petit), "medium" (moyen) ou "large" (grand). Plus il est grand, plus il est fort.
ressort.paired()true tant que l'autre ressort de la paire est en place et chargé.
ressort.set_length(blocks)Change la longueur de la paire, comme des clics avec l'objet ressort : ramenée entre 1 et 9 et arrondie au quart de bloc. Elle s'applique tout de suite, sur les deux ressorts, et la méthode renvoie la longueur retenue. Le ressort refuse une longueur trop loin de son état, et renvoie la raison à la place : "too_stretched" (trop étiré) quand on raccourcit une paire déjà écartée de plus d'environ deux fois la nouvelle longueur, "too_compressed" (trop comprimé) quand on allonge une paire écartée de moins d'environ la moitié.
volant.angle()L'angle où le volant est tourné en ce moment, en degrés : 0 au milieu, jusqu'à sa limite de chaque côté. Il avance à 96 degrés par seconde vers steering_wheel.target_angle().
volant.target_angle()L'angle vers lequel va le volant : le dernier fixé par le programme ou par un joueur.
volant.limit()Jusqu'où le volant tourne de chaque côté, en degrés, comme réglé sur son panneau.
volant.held()true tant qu'un joueur tient le volant. Ses mouvements l'emportent alors sur ceux du programme : attendez qu'il le lâche.
volant.set_target_angle(degrees)Tourne le volant vers cet angle, ramené dans sa limite, et renvoie l'angle retenu. Le volant le prend à la fin du tick, puis fait tourner son réseau de la différence, à 96 degrés par seconde.
volant.set_limit(degrees)Règle jusqu'où le volant peut tourner de chaque côté, comme son panneau, à la fin du tick. Ne renvoie rien. Le nombre doit être entier ; les valeurs hors de 1 à 360 sont ramenées dans l'intervalle.
t.cog_speed()La vitesse du côté roue dentée, en tr/min, négative quand elle tourne dans l'autre sens. speed() (kinetic.speed()) donne celle de l'arbre.
t.too_fast()true quand la transmission, entraînée par sa roue dentée, refuse parce que son arbre tournerait plus vite que Create ne le permet : baissez le signal ou la vitesse d'entrée.
moteur.burn_time()Les secondes restantes de l'objet qui brûle en ce moment (un morceau de charbon dure 80 secondes), 0 quand il est éteint.
moteur.total_burn_time()Les secondes de combustible en tout : ce qui reste de l'objet qui brûle, plus la pile qui attend dans son emplacement.
moteur.burning()true tant que le moteur brûle, et donc fait tourner son arbre.
moteur.superheated()true tant que le moteur brûle un combustible de surchauffe et tourne à 64 tr/min.
moteur.infinite()true avec un combustible qui ne s'épuise jamais (un Cake pour Blaze créatif) : les durées ne veulent alors plus rien dire.
moteur.direction()Le sens dans lequel le moteur fait tourner son arbre, comme sur son panneau : "clockwise" (sens horaire) ou "counter_clockwise" (sens antihoraire).
moteur.set_direction(way)Règle le sens de rotation du moteur, comme son panneau, à la fin du tick. Ne renvoie rien. Tout autre texte arrête le programme. Un moteur qui s'allume sur un réseau qui tourne déjà dans l'autre sens prend ce sens de lui-même.
pc.state()Où en est le canon dans son cycle : "charging" (en charge), "charged" (prêt à tirer) ou "firing" (en train de tirer, quelques ticks, avant de recharger).
pc.charge()La charge du canon, de 0 à 1. Elle n'avance pas sans munition ou sans rotation.
pc.loaded()true quand le canon a des munitions, un objet que peut tirer un Canon à pomme de terre.
pc.blocked()true tant qu'un bloc se trouve juste devant le canon : il ne tire pas.
support.strength()La force de la suspension, réglée sur son panneau : de 5 à 180, 10 pour un support neuf.
support.set_strength(n)Règle la force de la suspension, comme le panneau, à la fin du tick, et renvoie la valeur retenue.
support.steering()L'angle où la roue est braquée, en degrés, jusqu'à 30 de chaque côté ; 0 quand elle va tout droit. Il suit la redstone sur les côtés du support, et y arrive en quelques ticks.
support.tire()L'objet sur le support, sous forme d'id ("offroad:tire", "offroad:large_tire"...) ; nil sans pneu.
forage.running()true tant que la tête de forage est assemblée et tournée par le roulement.
forage.active()true pendant que la foreuse creuse : assemblée, en rotation, ni calée ni en train de ralentir.
forage.stalled()true tant que la foreuse cale parce que son stockage n'a plus de place pour ce qu'elle casse, et une demi-seconde encore après qu'elle a de nouveau de la place.
forage.stopping()true pendant que la tête de forage ralentit, après un disassemble() ou un clic, avant de redevenir des blocs.
forage.error()La raison du dernier assemblage raté, en une phrase en anglais (pas de roue de coupe, pas de bloc de stockage...) ; nil quand rien n'a échoué.
forage.assemble()Assemble la tête de forage au tick suivant du roulement, comme un clic. Elle ne s'assemble que si son arbre tourne : sur un roulement à l'arrêt, l'appel ne fait rien et renvoie false. Quand l'assemblage échoue, borehead_bearing.error() dit pourquoi.
forage.disassemble()Ralentit la tête de forage, puis la remet en blocs, comme un clic. borehead_bearing.stopping() vaut true pendant ce temps.

Levier d'accélération

Le levier d'accélération (Throttle Lever) est une source de redstone compacte à 16 positions : un joueur maintient le clic droit et le fait glisser, cran par cran, et il donne ce signal, de 0 à 15. Une Clé l'inverse : chaque position donne alors 15 moins son signal. L'ordinateur lit le signal et bouge le levier lui-même : un pilote et un pilote automatique peuvent se partager un seul levier.

#

levier.signal()

→ number

Le signal que donne le levier en ce moment, de 0 à 15, qu'il soit inversé ou non.

Renvoie
number
le signal de redstone que donne le levier, de 0 à 15
Brass
local levier = peripheral.find("throttle_lever")
print("gaz à " .. math.floor(levier.signal() / 15 * 100) .. " %")

Voir aussi throttle_lever.set_signal() throttle_lever.inverted()

#

levier.set_signal(power)

Place le levier, avec son clic, sur la position qui donne ce signal (un levier inversé prend lui aussi la position qui le donne). Le levier bouge à la fin du tick, et les blocs qu'il alimente voient le nouveau signal deux ticks plus tard. Ne renvoie rien. Les valeurs hors de 0 à 15 sont ramenées dans l'intervalle ; un nombre à virgule arrête le programme (arrondissez-le avec math.floor).

Paramètres
power number
le signal à donner, un nombre entier de 0 à 15
Brass
local levier = peripheral.find("throttle_lever")
levier.set_signal(10)

Voir aussi throttle_lever.signal()

#

levier.inverted()

→ boolean

true quand une Clé a inversé le levier : ses positions comptent dans l'autre sens, et celle qui donnait 3 donne maintenant 12. signal et set_signal en tiennent déjà compte.

Renvoie
boolean
true si une Clé a inversé le levier

Lasers

Un pointeur laser (Laser Pointer) projette un faisceau tant que la redstone l'alimente, aussi loin que sa portée (le panneau de réglage à l'arrière) ou jusqu'à ce qu'un bloc l'arrête. Une teinture utilisée dessus donne sa couleur au faisceau ; un Éclat d'améthyste lui rend la couleur améthyste de départ, et une Étoile du Nether le rend arc-en-ciel. Une Clé sur sa face avant ou arrière l'inverse : il brille alors à pleine puissance sans redstone, et s'éteint avec un signal de 15.

Un capteur laser (Laser Sensor) éclairé sur sa face avant par un faisceau donne la puissance de ce faisceau en redstone. Avec un objet dans son filtre (une teinture, un Éclat d'améthyste ou une Étoile du Nether), il ne voit que les faisceaux de cette couleur. Un joueur ou un mob debout dans le faisceau l'arrête avant le capteur : un faisceau en travers d'une porte fait un fil piège.

#

laser.power()

→ number

Le signal de redstone le plus fort autour du pointeur, de 0 (éteint) à 15 ; sur un pointeur inversé, 15 moins ce signal. C'est aussi la puissance que reçoit un capteur laser de son faisceau.

Renvoie
number
la puissance de redstone qui allume le pointeur, de 0 à 15
Brass
local laser = peripheral.find("laser_pointer")
print(laser.power(), laser.on())

Un pointeur qui touche l'ordinateur est allumé par l'ordinateur : rs.set("left", 15) quand il est à gauche.

Voir aussi laser_pointer.on() laser_sensor.power()

#

laser.on()

→ boolean

true tant que le pointeur projette son faisceau, c'est-à-dire tant que sa puissance est au-dessus de 0.

Renvoie
boolean
true tant que le faisceau brille
#

laser.range()

→ number

La longueur réglée sur le panneau du pointeur (« Max Casting Distance »), en blocs : de 1 au maximum du serveur (100 par défaut, configuration serveur laser_pointer_max_range). Un pointeur neuf commence au maximum.

Renvoie
number
la longueur maximale du faisceau, en blocs

Voir aussi laser_pointer.set_range() laser_pointer.distance()

#

laser.set_range(blocks)

→ number

Règle la longueur du faisceau, comme si l'on tournait le panneau, et renvoie la valeur retenue. Contrairement à la plupart des changements, elle s'applique tout de suite.

Paramètres
blocks number
la nouvelle longueur, un nombre entier de blocs
Renvoie
number
la longueur retenue, de 1 au maximum du serveur
Brass
local laser = peripheral.find("laser_pointer")
print(laser.set_range(20))
print(laser.set_range(100000))

Aux réglages par défaut, cela affiche 20, puis 100, le maximum du serveur.

Voir aussi laser_pointer.range()

#

laser.color()

→ string

La couleur du faisceau : le nom de la teinture qui l'a donnée ("red", "light_blue"...), "amethyst" (la couleur d'un pointeur neuf) ou "rainbow" (arc-en-ciel).

Renvoie
string
un nom de teinture comme "red" ou "light_blue", "amethyst" ou "rainbow"

Voir aussi laser_pointer.set_color() laser_sensor.filter()

#

laser.set_color(color)

Donne une couleur au faisceau, comme une teinture, un Éclat d'améthyste ou une Étoile du Nether utilisés sur le pointeur. Les noms de teinture sont ceux de Minecraft, en anglais : white, orange, magenta, light_blue, yellow, lime, pink, gray, light_gray, cyan, purple, blue, brown, green, red, black (grey marche aussi). Tout autre nom arrête le programme avec une erreur qui les liste. S'applique à la fin du tick ; ne renvoie rien.

Paramètres
color string
un nom de teinture, "amethyst" ou "rainbow"

Avec un filtre sur chaque capteur laser, la couleur choisit les capteurs qu'un seul pointeur allume :

Brass
local laser = peripheral.find("laser_pointer")
laser.set_color("red")    -- seuls les capteurs filtrés en rouge (ou sans filtre) le voient

Voir aussi laser_pointer.color()

#

laser.distance()

→ number|nil

Jusqu'où va le faisceau avant qu'un bloc l'arrête, en blocs, depuis l'avant du pointeur. nil tant que le pointeur est éteint, ou quand le faisceau va jusqu'au bout sans rencontrer de bloc. Les joueurs et les mobs ne comptent pas, seulement les blocs.

Renvoie
number|nil
la distance du premier bloc que touche le faisceau, en blocs ; nil s'il n'en touche aucun ou est éteint

Un télémètre : un pointeur allumé sous un navire, tourné vers le bas, lit la hauteur au-dessus du sol.

Brass
local laser = peripheral.find("laser_pointer")
local d = laser.distance()
if d then
  print(string.format("sol à %.1f blocs dessous", d))
else
  print("rien à moins de " .. laser.range() .. " blocs")
end

Voir aussi laser_pointer.range()

#

capteur.power()

→ number

La puissance du faisceau le plus fort qui atteint l'avant du capteur et passe son filtre, de 0 (aucun) à 15 : le signal de redstone que donne le capteur.

Renvoie
number
la puissance du faisceau le plus fort que reçoit le capteur, de 0 à 15
Brass
local capteur = peripheral.find("laser_sensor")
if capteur.power() == 0 then
  print("faisceau coupé !")
end

Voir aussi laser_pointer.power()

#

capteur.distance()

→ number|nil

La distance du pointeur le plus proche dont le faisceau atteint le capteur, en blocs, de l'avant de ce pointeur jusqu'au point où son faisceau touche le capteur. nil tant qu'aucun faisceau ne l'atteint.

Renvoie
number|nil
la distance du pointeur le plus proche dont le faisceau atteint le capteur, en blocs ; nil sans faisceau

Un pointeur sur un navire et un capteur sur son aire d'atterrissage disent à quelle distance est le navire :

Brass
local capteur = peripheral.find("laser_sensor")
local d = capteur.distance()
if d then
  print(string.format("navire à %.1f blocs", d))
end
#

capteur.filter()

→ string|nil

L'objet dans le filtre du capteur, sous forme d'id : une teinture ("minecraft:red_dye"), un Éclat d'améthyste ("minecraft:amethyst_shard") ou une Étoile du Nether ("minecraft:nether_star"). nil quand le filtre est vide : le capteur voit alors tous les faisceaux. Avec une teinture ou un éclat, il ne voit que les faisceaux de cette couleur ; avec une Étoile du Nether, seulement les faisceaux arc-en-ciel, qui à leur tour n'allument aucun capteur filtré par une teinture ou un éclat.

Renvoie
string|nil
l'id de l'objet dans le filtre du capteur, nil s'il est vide

Voir aussi laser_pointer.color()

Accumulateur et inducteur de redstone

Deux minuteries de redstone, chacune avec un délai sur son panneau de réglage, en ticks (20 par seconde).

L'accumulateur de redstone (Redstone Accumulator) garde un signal de 0 à 15, son compte : alimenté par l'arrière, il compte un cran de plus à chaque délai ; alimenté par un côté, il décompte ; alimenté des deux, il tient. Son délai va de 2 ticks à une heure (72000 ticks), 10 pour un neuf. Il donne son compte par l'avant ; un clic l'inverse, et il donne alors 15 moins son compte.

L'inducteur de redstone (Redstone Inductor) suit le signal sur son arrière, un cran par délai : sa sortie monte ou descend vers son entrée. Avec un délai de 0 (« Copy » sur son panneau), il prend son entrée en quelques ticks. Un clic l'inverse, et il donne alors 15 moins cette sortie.

#

acc.count()

→ number

Le compte que garde l'accumulateur, de 0 à 15 : ce qu'il donne tant qu'il n'est pas inversé.

Renvoie
number
le compte de l'accumulateur, de 0 à 15
Brass
local acc = peripheral.find("redstone_accumulator")
print(acc.count(), acc.output())

Voir aussi redstone_accumulator.output() redstone_accumulator.set_count()

#

acc.output()

→ number

Le signal que donne l'accumulateur par l'avant : son compte, ou 15 moins son compte quand il est inversé.

Renvoie
number
le signal que donne l'accumulateur, de 0 à 15
#

acc.set_count(n)

Règle le compte, ramené entre 0 et 15, à la fin du tick ; l'accumulateur continue de compter à partir de là. Ne renvoie rien. Une minuterie que l'ordinateur remet à zéro :

Paramètres
n number
le nouveau compte, un nombre entier de 0 à 15
Brass
local acc = peripheral.find("redstone_accumulator")
acc.set_count(0)

Voir aussi redstone_accumulator.count()

#

acc.delay()

→ number

Combien de ticks l'accumulateur attend entre deux crans, de 2 à 72000.

Renvoie
number
le délai de l'accumulateur, en ticks par cran

Voir aussi redstone_accumulator.set_delay()

#

acc.set_delay(ticks)

→ number

Règle le délai, comme le panneau, à la fin du tick, et renvoie la valeur retenue.

Paramètres
ticks number
le nouveau délai, un nombre entier de ticks
Renvoie
number
le délai retenu, de 2 à 72000
Brass
local acc = peripheral.find("redstone_accumulator")
acc.set_delay(20)   -- un cran par seconde
#

acc.inverted()

→ boolean

true quand un clic a inversé l'accumulateur : il donne 15 moins son compte.

Renvoie
boolean
true si l'accumulateur donne 15 moins son compte
#

ind.output()

→ number

Le signal que donne l'inducteur par l'avant, de 0 à 15, qu'il soit inversé ou non.

Renvoie
number
le signal que donne l'inducteur, de 0 à 15
Brass
local ind = peripheral.find("redstone_inductor")
print(ind.output())
#

ind.delay()

→ number

Combien de ticks l'inducteur attend entre deux crans, de 0 (il copie son entrée) à 72000.

Renvoie
number
le délai de l'inducteur, en ticks par cran

Voir aussi redstone_inductor.set_delay()

#

ind.set_delay(ticks)

→ number

Règle le délai, comme le panneau, à la fin du tick, et renvoie la valeur retenue.

Paramètres
ticks number
le nouveau délai, un nombre entier de ticks
Renvoie
number
le délai retenu, de 0 à 72000
Brass
local ind = peripheral.find("redstone_inductor")
ind.set_delay(5)
#

ind.inverted()

→ boolean

true quand un clic a inversé l'inducteur : il donne 15 moins le signal qu'il a atteint.

Renvoie
boolean
true si la sortie de l'inducteur est inversée

Assembleur physique

L'assembleur physique (Physics Assembler) fait d'une construction un véhicule de Create Aeronautics. Il se colle à un bloc, et tirer son levier fait de ce bloc et de tous les blocs collés à lui un véhicule qui tombe, flotte et vole avec une vraie physique ; les blocs se collent avec de la Colle extra-forte, ou avec la colle au miel de Simulated (Honey Glue). Tirer le levier de n'importe quel assembleur d'un véhicule le remet en blocs : le véhicule s'aligne d'abord sur la grille des blocs, tourné au quart de tour le plus proche, puis pose ses blocs.

Seuls ces véhicules physiques comptent (les Simulated Contraptions, que déplace le moteur physique Sable) : un bloc porté par une machine de Create, sur un roulement ou un train, n'est pas sur un véhicule.

L'assembleur part avec son véhicule. L'assembleur fait partie de ce qu'il assemble : une fois le véhicule créé, le bloc n'est plus là où l'ordinateur le voyait. Sauf si l'ordinateur est collé au même véhicule, le périphérique a alors disparu, et l'appel suivant arrête le programme avec physics assembler removed.

#

pa.assembled()

→ boolean

true tant que l'assembleur est sur un véhicule physique, celui qu'il a assemblé ou un autre.

Renvoie
boolean
true tant que l'assembleur est sur un véhicule
Brass
local pa = peripheral.find("physics_assembler")
if not pa.assembled() then
  pa.assemble()
end

Voir aussi physics_assembler.assemble() physics_assembler.disassemble()

#

pa.disassembling()

→ boolean

true après un disassemble() (ou un coup de levier) pendant que le véhicule tourne et se déplace pour s'aligner sur la grille des blocs, avant de poser ses blocs.

Renvoie
boolean
true pendant que le véhicule s'aligne pour redevenir des blocs
#

pa.error()

→ string|nil

La raison que donne le mod pour le dernier refus, en anglais, comme "Moving too fast to disassemble!". nil quand rien n'a échoué (un assemblage réussi l'efface). Aux réglages par défaut, un véhicule n'est pas défait tant qu'il va plus vite que 5 blocs par seconde, loin de tout sol, hors de la hauteur du monde, ou quand il n'arrive pas à s'aligner en 5 secondes.

Renvoie
string|nil
pourquoi le dernier assemblage ou désassemblage a échoué, en anglais ; nil si rien n'a échoué
#

pa.assemble()

→ boolean

Fait du bloc auquel l'assembleur est collé, et de tout ce qui est collé à lui, un véhicule, comme un coup de son levier. L'assemblage a lieu à la fin du tick ; quand il échoue, physics_assembler.error() dit pourquoi.

Renvoie
boolean
false si l'assembleur est déjà sur un véhicule, true sinon

Depuis le sol, la réussite se voit à l'assembleur qui a disparu :

Brass
local pa = peripheral.find("physics_assembler")
if pa.assemble() then
  sleep(0.1)
  local r = pcall(pa.error)
  if not r.ok then
    print("assemblé : l'assembleur est parti avec son véhicule")
  elseif r.value then
    print("pas assemblé : " .. r.value)
  end
end

Voir aussi physics_assembler.error()

#

pa.disassemble()

→ boolean

Remet le véhicule en blocs, comme un coup de levier sur un véhicule. À la fin du tick, le véhicule commence à s'aligner (physics_assembler.disassembling() vaut alors true), et pose ses blocs une fois en place. Un refus laisse le véhicule tel quel, avec la raison dans physics_assembler.error(). Pour un ordinateur à bord :

Renvoie
boolean
false si l'assembleur n'est pas sur un véhicule, true sinon
Brass
local pa = peripheral.find("physics_assembler")
if pa.assembled() then
  pa.disassemble()
end

Voir aussi physics_assembler.disassembling() physics_assembler.error()

Treuil

Le treuil (Rope Winch) enroule et déroule une corde. Une attache de corde (Rope Coupling) le relie à un connecteur de corde (Rope Connector) ; deux treuils ne se relient pas entre eux. La corde tient ou remorque alors ce à quoi elle est attachée. Tourné par un arbre, le treuil déroule ou enroule la corde, selon son sens de rotation, à une vitesse en blocs par seconde égale aux tr/min divisés par 25,6 (9,8 au plus). La corde fait au plus 40 blocs (configuration serveur max_rope_range). Quand la charge tire la corde de plus de 25 % au-delà de sa longueur (configuration serveur max_rope_winch_stretch_allowed), la corde est tendue, et le treuil n'enroule plus.

L'ordinateur ne fait pas tourner le treuil lui-même : il règle la vitesse de son arbre, par exemple avec un Contrôleur de vitesse de rotation (kinetic.set_speed()).

#

treuil.attached()

→ boolean

true tant qu'une corde est attachée au treuil.

Renvoie
boolean
true tant qu'une corde est attachée au treuil
Brass
local treuil = peripheral.find("rope_winch")
print(treuil.attached(), treuil.length())
#

treuil.length()

→ number|nil

La longueur de la corde en ce moment, en blocs, mesurée le long de la corde. nil sans corde.

Renvoie
number|nil
la longueur de la corde en ce moment, en blocs ; nil sans corde

Une grue qui déroule la corde jusqu'à 20 blocs, puis s'arrête. Son treuil tourne par un Contrôleur de vitesse de rotation derrière l'ordinateur ; si la corde rentre au lieu de sortir, mettez -32.

Brass
local treuil = peripheral.find("rope_winch")
local moteur = peripheral.wrap("back")
moteur.set_speed(32)
while true do
  local longueur = treuil.length()
  if not longueur or longueur >= 20 then
    break
  end
  sleep(0.1)
end
moteur.set_speed(0)

Voir aussi rope_winch.max_length()

#

treuil.max_length()

→ number

La longueur maximale jusqu'à laquelle le treuil déroule sa corde, en blocs : 40 par défaut (configuration serveur max_rope_range).

Renvoie
number
la corde la plus longue que déroule le treuil, en blocs
#

treuil.reel_speed()

→ number

La vitesse à laquelle l'arbre fait dérouler la corde au treuil, en blocs par seconde : les tr/min divisés par 25,6, au plus 9,8. Négative quand il enroule, 0 à l'arrêt. C'est ce que demande l'arbre : une corde tendue ne rentre pas, et une corde à sa longueur maximale ne sort plus.

Renvoie
number
la vitesse à laquelle le treuil déroule, en blocs par seconde ; négative quand il enroule
Brass
local treuil = peripheral.find("rope_winch")
print(string.format("%.2f blocs/s", treuil.reel_speed()))

Voir aussi rope_winch.stretched()

#

treuil.stretched()

→ boolean

true tant que la charge tire la corde de plus de 25 % au-delà de sa longueur : le treuil refuse alors d'enrouler. Allégez la charge, ou déroulez un peu de corde.

Renvoie
boolean
true tant que la corde est tendue au-delà de ce que permet le treuil

Ressort

Un ressort (Spring) relie deux blocs : cliquez sur l'un, puis sur l'autre, avec l'objet ressort, et un bloc de ressort apparaît sur chacun. La paire tire ou pousse pour garder les deux blocs à sa longueur, de 1 à 9 blocs, quand l'un des deux au moins est sur un véhicule : un ressort suspend une nacelle sous un ballon, ou adoucit un atterrissage. Un joueur change la longueur avec l'objet ressort, d'un quart de bloc par clic (accroupi pour raccourcir), et la force avec une Clé : petit, moyen ou grand (le grand est 16 fois plus fort que le petit). Casser un ressort casse l'autre, et une paire étirée à plus de 4 fois sa longueur plus 2 blocs se rompt en moins d'une seconde.

#

ressort.length()

→ number

La longueur vers laquelle la paire tire ou pousse, en blocs, de 1 à 9 par quarts. Les deux ressorts d'une paire lisent la même.

Renvoie
number
la longueur que tient la paire, de 1 à 9 blocs
Brass
local ressort = peripheral.find("spring")
print(ressort.length(), ressort.distance())

Voir aussi spring.set_length() spring.distance()

#

ressort.distance()

→ number|nil

L'écart entre les deux ressorts de la paire en ce moment, en blocs, de centre à centre, où que soient leurs véhicules. Comparé à spring.length(), il dit si le ressort est étiré ou comprimé.

Renvoie
number|nil
l'écart entre les deux ressorts en ce moment, en blocs ; nil sans partenaire
#

ressort.size()

→ string

La taille du ressort, que change une Clé : "small" (petit), "medium" (moyen) ou "large" (grand). Plus il est grand, plus il est fort.

Renvoie
string
"small", "medium" ou "large"
#

ressort.paired()

→ boolean

true tant que l'autre ressort de la paire est en place et chargé.

Renvoie
boolean
true tant que l'autre ressort de la paire est là
#

ressort.set_length(blocks)

→ number|string

Change la longueur de la paire, comme des clics avec l'objet ressort : ramenée entre 1 et 9 et arrondie au quart de bloc. Elle s'applique tout de suite, sur les deux ressorts, et la méthode renvoie la longueur retenue. Le ressort refuse une longueur trop loin de son état, et renvoie la raison à la place : "too_stretched" (trop étiré) quand on raccourcit une paire déjà écartée de plus d'environ deux fois la nouvelle longueur, "too_compressed" (trop comprimé) quand on allonge une paire écartée de moins d'environ la moitié.

Paramètres
blocks number
la nouvelle longueur, en blocs
Renvoie
number|string
la longueur retenue, ou pourquoi le ressort refuse ("too_stretched", "too_compressed")
Brass
local ressort = peripheral.find("spring")
local r = ressort.set_length(6)
if type(r) == "string" then
  print("refusé : " .. r)
else
  print("longueur " .. r)
end

Un ressort change une fois par tick : un second appel sur le même ressort dans le même tick arrête le programme avec the spring already changed this tick: sleep(0) waits for the next.

Voir aussi spring.length()

Volant

Un joueur saisit le volant (Steering Wheel) en maintenant le clic droit et le tourne avec la souris, jusqu'à sa limite de chaque côté (un panneau de réglage, de 1 à 360 degrés, 180 pour un volant neuf). Le volant est une source de rotation : comme un Inverseur de rotation séquencé, il fait tourner son réseau d'exactement l'angle dont on le tourne, à son propre rythme de 16 tr/min (96 degrés par seconde). Un roulement qu'il entraîne pivote de cet angle : le gouvernail d'un navire, l'essieu avant d'un chariot. Un Roulement mécanique doit être réglé pour ne jamais se désassembler, sinon il se défait chaque fois que le volant s'arrête.

L'ordinateur donne au volant un angle vers lequel tourner, et le volant fait tourner son réseau de la différence, à son rythme. Si l'angle change pendant que le volant tourne encore, il finit son mouvement, puis part vers le nouvel angle. Un joueur qui tient le volant l'emporte : chacun de ses mouvements fixe un nouvel angle par-dessus celui du programme.

#

volant.angle()

→ number

L'angle où le volant est tourné en ce moment, en degrés : 0 au milieu, jusqu'à sa limite de chaque côté. Il avance à 96 degrés par seconde vers steering_wheel.target_angle().

Renvoie
number
l'angle où le volant est tourné, en degrés
Brass
local volant = peripheral.find("steering_wheel")
print(volant.angle(), volant.target_angle())

Voir aussi steering_wheel.target_angle()

#

volant.target_angle()

→ number

L'angle vers lequel va le volant : le dernier fixé par le programme ou par un joueur.

Renvoie
number
l'angle vers lequel tourne le volant, en degrés
#

volant.limit()

→ number

Jusqu'où le volant tourne de chaque côté, en degrés, comme réglé sur son panneau.

Renvoie
number
jusqu'où le volant tourne de chaque côté, de 1 à 360 degrés

Voir aussi steering_wheel.set_limit()

#

volant.held()

→ boolean

true tant qu'un joueur tient le volant. Ses mouvements l'emportent alors sur ceux du programme : attendez qu'il le lâche.

Renvoie
boolean
true tant qu'un joueur tient le volant
Brass
local volant = peripheral.find("steering_wheel")
while volant.held() do
  sleep(0.5)
end
#

volant.set_target_angle(degrees)

→ number

Tourne le volant vers cet angle, ramené dans sa limite, et renvoie l'angle retenu. Le volant le prend à la fin du tick, puis fait tourner son réseau de la différence, à 96 degrés par seconde.

Paramètres
degrees number
l'angle vers lequel tourner, négatif pour l'autre sens
Renvoie
number
l'angle retenu, dans la limite du volant
Brass
local volant = peripheral.find("steering_wheel")
print(volant.set_target_angle(-45))
print(volant.set_target_angle(1000))

Pour un volant neuf, cela affiche -45, puis 180, sa limite.

Voir aussi steering_wheel.angle() steering_wheel.held()

#

volant.set_limit(degrees)

Règle jusqu'où le volant peut tourner de chaque côté, comme son panneau, à la fin du tick. Ne renvoie rien. Le nombre doit être entier ; les valeurs hors de 1 à 360 sont ramenées dans l'intervalle.

Paramètres
degrees number
la nouvelle limite, un nombre entier de degrés de 1 à 360
Brass
local volant = peripheral.find("steering_wheel")
volant.set_limit(90)

Transmission analogique

La transmission analogique (Analog Transmission) est un arbre et une roue dentée dans un seul bloc, que la redstone sépare. Sans redstone, les deux tournent à la même vitesse, comme une roue dentée dans un boîtier. Un signal de 1 à 14 ralentit la roue dentée : elle tourne à (15 - signal) / 16 de la vitesse de l'arbre, la moitié avec un signal de 7. À 15, les deux se séparent et tournent chacun de leur côté. Entraînée par la roue dentée, c'est l'arbre qui accélère, du rapport inverse ; quand l'arbre tournerait plus vite que Create ne le permet (256 tr/min par défaut), la transmission refuse (« Too Fast ») et l'arbre s'arrête.

L'ordinateur règle le rapport avec la redstone, rs.set(face, signal) depuis la face qui la touche, et lit le résultat.

#

t.cog_speed()

→ number

La vitesse du côté roue dentée, en tr/min, négative quand elle tourne dans l'autre sens. speed() (kinetic.speed()) donne celle de l'arbre.

Renvoie
number
la vitesse du côté roue dentée, en tr/min
Brass
local t = peripheral.find("analog_transmission")
rs.set("left", 7)   -- la transmission est à gauche de l'ordinateur
sleep(0.5)
print("arbre " .. t.speed() .. ", roue dentée " .. t.cog_speed() .. " tr/min")

Avec l'arbre à 64 tr/min, la roue dentée tourne à 32.

Voir aussi kinetic.speed()

#

t.too_fast()

→ boolean

true quand la transmission, entraînée par sa roue dentée, refuse parce que son arbre tournerait plus vite que Create ne le permet : baissez le signal ou la vitesse d'entrée.

Renvoie
boolean
true quand la transmission refuse de faire tourner son arbre trop vite

Moteur portable

Le moteur portable (Portable Engine) brûle du combustible de fourneau pour faire tourner son arbre à 32 tr/min ; un combustible de surchauffe (un Cake pour Blaze, comme pour un Brûleur à Blaze) le fait tourner deux fois plus vite. Il prend son combustible à la main ou par un entonnoir, et mange un gâteau posé devant lui, 5 secondes de combustible par bouchée ; un Cake pour Blaze créatif le fait brûler pour toujours. Son panneau de réglage choisit son sens de rotation.

#

moteur.burn_time()

→ number

Les secondes restantes de l'objet qui brûle en ce moment (un morceau de charbon dure 80 secondes), 0 quand il est éteint.

Renvoie
number
les secondes restantes du combustible qui brûle en ce moment
Brass
local moteur = peripheral.find("portable_engine")
print(moteur.burn_time(), moteur.total_burn_time())

Voir aussi portable_engine.total_burn_time()

#

moteur.total_burn_time()

→ number

Les secondes de combustible en tout : ce qui reste de l'objet qui brûle, plus la pile qui attend dans son emplacement.

Renvoie
number
les secondes de combustible en tout, la pile en attente comprise
Brass
local moteur = peripheral.find("portable_engine")
if not moteur.infinite() and moteur.total_burn_time() < 60 then
  print("Moins d'une minute de combustible")
end
#

moteur.burning()

→ boolean

true tant que le moteur brûle, et donc fait tourner son arbre.

Renvoie
boolean
true tant que le moteur brûle du combustible
#

moteur.superheated()

→ boolean

true tant que le moteur brûle un combustible de surchauffe et tourne à 64 tr/min.

Renvoie
boolean
true tant qu'il brûle un combustible de surchauffe, deux fois plus vite
#

moteur.infinite()

→ boolean

true avec un combustible qui ne s'épuise jamais (un Cake pour Blaze créatif) : les durées ne veulent alors plus rien dire.

Renvoie
boolean
true si le combustible ne s'épuise jamais
#

moteur.direction()

→ string

Le sens dans lequel le moteur fait tourner son arbre, comme sur son panneau : "clockwise" (sens horaire) ou "counter_clockwise" (sens antihoraire).

Renvoie
string
"clockwise" ou "counter_clockwise"

Voir aussi portable_engine.set_direction()

#

moteur.set_direction(way)

Règle le sens de rotation du moteur, comme son panneau, à la fin du tick. Ne renvoie rien. Tout autre texte arrête le programme. Un moteur qui s'allume sur un réseau qui tourne déjà dans l'autre sens prend ce sens de lui-même.

Paramètres
way string
"clockwise" ou "counter_clockwise"
Brass
local moteur = peripheral.find("portable_engine")
moteur.set_direction("clockwise")

Canon à pomme de terre monté

Le canon à pomme de terre monté (Mounted Potato Cannon) est le Canon à pomme de terre de Create en bloc. Il prend les mêmes munitions (à la main ou par un entonnoir), et un arbre le charge : à 64 tr/min, il est prêt dans le temps de rechargement de sa munition, plus tôt s'il tourne plus vite. Une fois chargé, un signal de redstone le fait tirer, et un signal continu le fait tirer à nouveau à chaque recharge. Il ne tire pas tant qu'un bloc se trouve juste devant son canon (sauf une Trappe en palétuvier). Sur un véhicule, chaque tir le repousse en arrière.

Aucune méthode ne le fait tirer : l'ordinateur lui donne de la redstone, rs.set(face, true) depuis la face qui le touche, ou par une Liaison de redstone (link).

#

pc.state()

→ string

Où en est le canon dans son cycle : "charging" (en charge), "charged" (prêt à tirer) ou "firing" (en train de tirer, quelques ticks, avant de recharger).

Renvoie
string
"charging", "charged" ou "firing"

Un canon posé sur l'ordinateur, qui tire une fois prêt :

Brass
local pc = peripheral.wrap("top")
if pc.loaded() and pc.state() == "charged" then
  rs.set("top", true)
  sleep(0.2)
  rs.set("top", false)
end

Voir aussi mounted_potato_cannon.charge()

#

pc.charge()

→ number

La charge du canon, de 0 à 1. Elle n'avance pas sans munition ou sans rotation.

Renvoie
number
la charge du canon, de 0 à 1
#

pc.loaded()

→ boolean

true quand le canon a des munitions, un objet que peut tirer un Canon à pomme de terre.

Renvoie
boolean
true si le canon a des munitions
#

pc.blocked()

→ boolean

true tant qu'un bloc se trouve juste devant le canon : il ne tire pas.

Renvoie
boolean
true tant qu'un bloc devant le canon l'empêche de tirer

Support de roue

Le support de roue (Wheel Mount) porte un pneu sur sa face avant (Tire, Small Tire, Large Tire ou Monstrous Tire) et, sur un véhicule, le fait rouler au sol : sa suspension porte le véhicule, et son arbre entraîne la roue. La redstone fait le reste :

  • sur un côté, elle braque la roue vers ce côté, jusqu'à 30 degrés avec un signal de 15 (les signaux des deux côtés se soustraient) ;
  • sur le dessus, elle freine, d'autant plus fort que le signal est fort ; à 15, l'arbre n'entraîne plus la roue.

Aucune méthode ne braque ni ne freine : l'ordinateur donne de la redstone, avec rs.set depuis la face qui touche le support, ou par une Liaison de redstone posée à côté (link). Il lit où la roue est braquée, et règle la force de la suspension.

#

support.strength()

→ number

La force de la suspension, réglée sur son panneau : de 5 à 180, 10 pour un support neuf.

Renvoie
number
la force de la suspension, de 5 à 180
Brass
local support = peripheral.find("wheel_mount")
print(support.strength(), support.steering(), support.tire())

Voir aussi wheel_mount.set_strength()

#

support.set_strength(n)

→ number

Règle la force de la suspension, comme le panneau, à la fin du tick, et renvoie la valeur retenue.

Paramètres
n number
la nouvelle force, un nombre entier de 5 à 180
Renvoie
number
la force retenue
Brass
local support = peripheral.find("wheel_mount")
support.set_strength(40)
#

support.steering()

→ number

L'angle où la roue est braquée, en degrés, jusqu'à 30 de chaque côté ; 0 quand elle va tout droit. Il suit la redstone sur les côtés du support, et y arrive en quelques ticks.

Renvoie
number
l'angle de braquage de la roue, en degrés, 0 tout droit

Un support sous l'ordinateur, freiné et lu :

Brass
local support = peripheral.wrap("bottom")
rs.set("bottom", 15)   -- frein à fond
print("braqué de " .. support.steering() .. " degrés")
#

support.tire()

→ string|nil

L'objet sur le support, sous forme d'id ("offroad:tire", "offroad:large_tire"...) ; nil sans pneu.

Renvoie
string|nil
l'id du pneu sur le support, nil sans pneu

Roulement de tête de forage

Le roulement de tête de forage (Borehead Bearing) est une foreuse. Comme un Roulement mécanique, il fait tourner la structure devant lui, ici une tête de forage avec des roues de coupe (Rock Cutting Wheel) et au moins un bloc de stockage (un coffre, un Coffre à objet renforcé...). Il la tourne au quart de la vitesse de son arbre (configuration serveur borehead_bearing_rotation_divisor), chaque roue de coupe casse les blocs autour d'elle, et ce qui tombe va dans le stockage. Quand le stockage est plein, la foreuse cale jusqu'à ce qu'on en sorte des objets (on peut les extraire par le roulement lui-même). Un clic main vide l'assemble tant que son arbre tourne, ou la ralentit et la défait ; elle s'assemble aussi d'elle-même quand son arbre se met à tourner.

#

forage.running()

→ boolean

true tant que la tête de forage est assemblée et tournée par le roulement.

Renvoie
boolean
true tant que la tête de forage est assemblée
Brass
local forage = peripheral.find("borehead_bearing")
print(forage.running(), forage.active())

Voir aussi borehead_bearing.active()

#

forage.active()

→ boolean

true pendant que la foreuse creuse : assemblée, en rotation, ni calée ni en train de ralentir.

Renvoie
boolean
true pendant que la foreuse creuse
#

forage.stalled()

→ boolean

true tant que la foreuse cale parce que son stockage n'a plus de place pour ce qu'elle casse, et une demi-seconde encore après qu'elle a de nouveau de la place.

Renvoie
boolean
true tant que la foreuse cale parce que son stockage est plein

Une foreuse qui s'arrête quand elle est pleine, et le dit :

Brass
local forage = peripheral.find("borehead_bearing")
while not forage.stalled() do
  sleep(1)
end
forage.disassemble()
print("Stockage plein : foreuse arrêtée")
#

forage.stopping()

→ boolean

true pendant que la tête de forage ralentit, après un disassemble() ou un clic, avant de redevenir des blocs.

Renvoie
boolean
true pendant que la foreuse ralentit avant d'être défaite
#

forage.error()

→ string|nil

La raison du dernier assemblage raté, en une phrase en anglais (pas de roue de coupe, pas de bloc de stockage...) ; nil quand rien n'a échoué.

Renvoie
string|nil
pourquoi la foreuse n'a pas pu s'assembler, en anglais ; nil si elle a pu
#

forage.assemble()

→ boolean

Assemble la tête de forage au tick suivant du roulement, comme un clic. Elle ne s'assemble que si son arbre tourne : sur un roulement à l'arrêt, l'appel ne fait rien et renvoie false. Quand l'assemblage échoue, borehead_bearing.error() dit pourquoi.

Renvoie
boolean
false si la foreuse est déjà assemblée ou si son arbre ne tourne pas, true sinon

Voir aussi borehead_bearing.error()

#

forage.disassemble()

→ boolean

Ralentit la tête de forage, puis la remet en blocs, comme un clic. borehead_bearing.stopping() vaut true pendant ce temps.

Renvoie
boolean
false si la foreuse n'est pas assemblée, true sinon

Voir aussi borehead_bearing.stopping()

Un pilote automatique au volant

Un navire qui tient son cap. Un Microcontrôleur collé à bord (ou tout ordinateur qui a vehicle) touche le volant, qui tourne le roulement de l'hélice de queue ou d'un gouvernail. Le programme tourne le volant d'un angle qui grandit avec l'écart au cap, et le relâche quand le navire tourne déjà (voir vehicle.spin()). Quand un joueur prend le volant, le programme le laisse diriger, et reprend la main quand il le lâche. Si le navire tourne du mauvais côté, rendez GAIN et FREIN négatifs.

Brass
local CAP = 90       -- le cap à tenir : 0 nord, 90 est, 180 sud, 270 ouest
local PROUE = 0      -- là où pointait la proue quand le navire a été assemblé
local GAIN = 1.5     -- degrés de volant par degré d'écart au cap
local FREIN = 2      -- degrés de volant par degré par seconde de rotation
local volant = peripheral.find("steering_wheel")

local function ecart(cap, cible)
  return (cible - cap + 540) % 360 - 180
end

if not vehicle.on_vehicle() then
  print("Collez-moi d'abord sur le navire.")
  return
end
volant.set_limit(60)
while true do
  if volant.held() then
    print("Pilote au volant")
    while volant.held() do
      sleep(0.5)
    end
    print("Pilote automatique")
  end
  local actuel = (PROUE - vehicle.rotation().yaw) % 360
  local hors = ecart(actuel, CAP)   -- au-dessus de 0 : le cap est à droite
  volant.set_target_angle(hors * GAIN + vehicle.spin().yaw * FREIN)
  sleep(0.2)
end

Le volant garde l'angle dans sa limite (60 degrés ici), et y tourne à son rythme. Réglez-le comme dans vehicle.spin() : un navire qui dépasse son cap et revient demande plus de FREIN ou moins de GAIN.