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.
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érique | ce qu'il lit ou règle |
|---|---|---|
| levier d'accélération (Throttle Lever) | throttle_lever | son signal de redstone, qu'il peut régler |
| pointeur laser (Laser Pointer) | laser_pointer | son faisceau : puissance, longueur, couleur, ce qu'il touche |
| capteur laser (Laser Sensor) | laser_sensor | le faisceau qu'il reçoit, et la distance de son pointeur |
| accumulateur de redstone (Redstone Accumulator) | redstone_accumulator | son compte, qu'il peut régler, et son délai |
| inducteur de redstone (Redstone Inductor) | redstone_inductor | sa sortie et son délai |
| assembleur physique (Physics Assembler) | physics_assembler | assemble un véhicule et le défait |
| treuil (Rope Winch) | rope_winch | la longueur de sa corde et sa vitesse d'enroulement |
| ressort (Spring) | spring | la longueur qu'il tient, qu'il peut changer |
| volant (Steering Wheel) | steering_wheel | son angle, qu'il peut régler |
| transmission analogique (Analog Transmission) | analog_transmission | la vitesse de sa roue dentée |
| moteur portable (Portable Engine) | portable_engine | son combustible et son sens de rotation |
| canon à pomme de terre monté (Mounted Potato Cannon) | mounted_potato_cannon | sa charge et ses munitions |
| support de roue (Wheel Mount) | wheel_mount | sa suspension, son braquage et son pneu |
| roulement de tête de forage (Borehead Bearing) | borehead_bearing | s'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.
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 :
| erreur | quand |
|---|---|
steering wheel 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_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 getState | votre 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.
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()
Le signal que donne le levier en ce moment, de 0 à 15, qu'il soit inversé ou non.
- number
- le signal de redstone que donne le levier, de 0 à 15
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).
powernumber- le signal à donner, un nombre entier de 0 à 15
local levier = peripheral.find("throttle_lever")
levier.set_signal(10)Voir aussi throttle_lever.signal()
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.
- 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()
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.
- number
- la puissance de redstone qui allume le pointeur, de 0 à 15
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()
true tant que le pointeur projette son faisceau, c'est-à-dire tant que sa puissance est au-dessus de 0.
- boolean
- true tant que le faisceau brille
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.
- number
- la longueur maximale du faisceau, en blocs
Voir aussi laser_pointer.set_range() laser_pointer.distance()
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.
blocksnumber- la nouvelle longueur, un nombre entier de blocs
- number
- la longueur retenue, de 1 au maximum du serveur
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()
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).
- 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.
colorstring- un nom de teinture, "amethyst" ou "rainbow"
Avec un filtre sur chaque capteur laser, la couleur choisit les capteurs qu'un seul pointeur allume :
local laser = peripheral.find("laser_pointer")
laser.set_color("red") -- seuls les capteurs filtrés en rouge (ou sans filtre) le voientVoir aussi laser_pointer.color()
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.
- 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.
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")
endVoir aussi laser_pointer.range()
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.
- number
- la puissance du faisceau le plus fort que reçoit le capteur, de 0 à 15
local capteur = peripheral.find("laser_sensor")
if capteur.power() == 0 then
print("faisceau coupé !")
endVoir aussi laser_pointer.power()
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.
- 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 :
local capteur = peripheral.find("laser_sensor")
local d = capteur.distance()
if d then
print(string.format("navire à %.1f blocs", d))
endcapteur.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.
- 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()
Le compte que garde l'accumulateur, de 0 à 15 : ce qu'il donne tant qu'il n'est pas inversé.
- number
- le compte de l'accumulateur, de 0 à 15
local acc = peripheral.find("redstone_accumulator")
print(acc.count(), acc.output())Voir aussi redstone_accumulator.output() redstone_accumulator.set_count()
acc.output()
Le signal que donne l'accumulateur par l'avant : son compte, ou 15 moins son compte quand il est inversé.
- 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 :
nnumber- le nouveau compte, un nombre entier de 0 à 15
local acc = peripheral.find("redstone_accumulator")
acc.set_count(0)Voir aussi redstone_accumulator.count()
acc.delay()
Combien de ticks l'accumulateur attend entre deux crans, de 2 à 72000.
- number
- le délai de l'accumulateur, en ticks par cran
Voir aussi redstone_accumulator.set_delay()
acc.set_delay(ticks)
Règle le délai, comme le panneau, à la fin du tick, et renvoie la valeur retenue.
ticksnumber- le nouveau délai, un nombre entier de ticks
- number
- le délai retenu, de 2 à 72000
local acc = peripheral.find("redstone_accumulator")
acc.set_delay(20) -- un cran par secondeacc.inverted()
true quand un clic a inversé l'accumulateur : il donne 15 moins son compte.
- boolean
- true si l'accumulateur 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.
- number
- le signal que donne l'inducteur, de 0 à 15
local ind = peripheral.find("redstone_inductor")
print(ind.output())ind.delay()
Combien de ticks l'inducteur attend entre deux crans, de 0 (il copie son entrée) à 72000.
- number
- le délai de l'inducteur, en ticks par cran
Voir aussi redstone_inductor.set_delay()
ind.set_delay(ticks)
Règle le délai, comme le panneau, à la fin du tick, et renvoie la valeur retenue.
ticksnumber- le nouveau délai, un nombre entier de ticks
- number
- le délai retenu, de 0 à 72000
local ind = peripheral.find("redstone_inductor")
ind.set_delay(5)ind.inverted()
true quand un clic a inversé l'inducteur : il donne 15 moins le signal qu'il a atteint.
- 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()
true tant que l'assembleur est sur un véhicule physique, celui qu'il a assemblé ou un autre.
- boolean
- true tant que l'assembleur est sur un véhicule
local pa = peripheral.find("physics_assembler")
if not pa.assembled() then
pa.assemble()
endVoir aussi physics_assembler.assemble() physics_assembler.disassemble()
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.
- boolean
- true pendant que le véhicule s'aligne pour redevenir des 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.
- string|nil
- pourquoi le dernier assemblage ou désassemblage a échoué, en anglais ; nil si rien n'a échoué
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.
- 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 :
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
endVoir aussi physics_assembler.error()
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 :
- boolean
- false si l'assembleur n'est pas sur un véhicule, true sinon
local pa = peripheral.find("physics_assembler")
if pa.assembled() then
pa.disassemble()
endVoir 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()
true tant qu'une corde est attachée au treuil.
- boolean
- true tant qu'une corde est attachée au treuil
local treuil = peripheral.find("rope_winch")
print(treuil.attached(), treuil.length())treuil.length()
La longueur de la corde en ce moment, en blocs, mesurée le long de la corde. nil sans corde.
- 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.
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()
La longueur maximale jusqu'à laquelle le treuil déroule sa corde, en blocs : 40 par défaut (configuration serveur max_rope_range).
- number
- la corde la plus longue que déroule le treuil, en blocs
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.
- number
- la vitesse à laquelle le treuil déroule, en blocs par seconde ; négative quand il enroule
local treuil = peripheral.find("rope_winch")
print(string.format("%.2f blocs/s", treuil.reel_speed()))Voir aussi rope_winch.stretched()
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.
- 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()
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.
- number
- la longueur que tient la paire, de 1 à 9 blocs
local ressort = peripheral.find("spring")
print(ressort.length(), ressort.distance())Voir aussi spring.set_length() spring.distance()
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é.
- number|nil
- l'écart entre les deux ressorts en ce moment, en blocs ; nil sans partenaire
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.
- string
- "small", "medium" ou "large"
ressort.paired()
true tant que l'autre ressort de la paire est en place et chargé.
- boolean
- true tant que l'autre ressort de la paire est là
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é.
blocksnumber- la nouvelle longueur, en blocs
- number|string
- la longueur retenue, ou pourquoi le ressort refuse ("too_stretched", "too_compressed")
local ressort = peripheral.find("spring")
local r = ressort.set_length(6)
if type(r) == "string" then
print("refusé : " .. r)
else
print("longueur " .. r)
endUn 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()
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().
- number
- l'angle où le volant est tourné, en degrés
local volant = peripheral.find("steering_wheel")
print(volant.angle(), volant.target_angle())Voir aussi steering_wheel.target_angle()
volant.target_angle()
L'angle vers lequel va le volant : le dernier fixé par le programme ou par un joueur.
- number
- l'angle vers lequel tourne le volant, en degrés
volant.limit()
Jusqu'où le volant tourne de chaque côté, en degrés, comme réglé sur son panneau.
- number
- jusqu'où le volant tourne de chaque côté, de 1 à 360 degrés
Voir aussi steering_wheel.set_limit()
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.
- boolean
- true tant qu'un joueur tient le volant
local volant = peripheral.find("steering_wheel")
while volant.held() do
sleep(0.5)
endvolant.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.
degreesnumber- l'angle vers lequel tourner, négatif pour l'autre sens
- number
- l'angle retenu, dans la limite du volant
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.
degreesnumber- la nouvelle limite, un nombre entier de degrés de 1 à 360
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()
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.
- number
- la vitesse du côté roue dentée, en tr/min
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()
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.
- 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()
Les secondes restantes de l'objet qui brûle en ce moment (un morceau de charbon dure 80 secondes), 0 quand il est éteint.
- number
- les secondes restantes du combustible qui brûle en ce moment
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()
Les secondes de combustible en tout : ce qui reste de l'objet qui brûle, plus la pile qui attend dans son emplacement.
- number
- les secondes de combustible en tout, la pile en attente comprise
local moteur = peripheral.find("portable_engine")
if not moteur.infinite() and moteur.total_burn_time() < 60 then
print("Moins d'une minute de combustible")
endmoteur.burning()
true tant que le moteur brûle, et donc fait tourner son arbre.
- boolean
- true tant que le moteur brûle du combustible
moteur.superheated()
true tant que le moteur brûle un combustible de surchauffe et tourne à 64 tr/min.
- boolean
- true tant qu'il brûle un combustible de surchauffe, deux fois plus vite
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.
- boolean
- true si le combustible ne s'épuise jamais
moteur.direction()
Le sens dans lequel le moteur fait tourner son arbre, comme sur son panneau : "clockwise" (sens horaire) ou "counter_clockwise" (sens antihoraire).
- 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.
waystring- "clockwise" ou "counter_clockwise"
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()
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).
- string
- "charging", "charged" ou "firing"
Un canon posé sur l'ordinateur, qui tire une fois prêt :
local pc = peripheral.wrap("top")
if pc.loaded() and pc.state() == "charged" then
rs.set("top", true)
sleep(0.2)
rs.set("top", false)
endVoir aussi mounted_potato_cannon.charge()
pc.charge()
La charge du canon, de 0 à 1. Elle n'avance pas sans munition ou sans rotation.
- number
- la charge du canon, de 0 à 1
pc.loaded()
true quand le canon a des munitions, un objet que peut tirer un Canon à pomme de terre.
- boolean
- true si le canon a des munitions
pc.blocked()
true tant qu'un bloc se trouve juste devant le canon : il ne tire pas.
- 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()
La force de la suspension, réglée sur son panneau : de 5 à 180, 10 pour un support neuf.
- number
- la force de la suspension, de 5 à 180
local support = peripheral.find("wheel_mount")
print(support.strength(), support.steering(), support.tire())Voir aussi wheel_mount.set_strength()
support.set_strength(n)
Règle la force de la suspension, comme le panneau, à la fin du tick, et renvoie la valeur retenue.
nnumber- la nouvelle force, un nombre entier de 5 à 180
- number
- la force retenue
local support = peripheral.find("wheel_mount")
support.set_strength(40)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.
- number
- l'angle de braquage de la roue, en degrés, 0 tout droit
Un support sous l'ordinateur, freiné et lu :
local support = peripheral.wrap("bottom")
rs.set("bottom", 15) -- frein à fond
print("braqué de " .. support.steering() .. " degrés")support.tire()
L'objet sur le support, sous forme d'id ("offroad:tire", "offroad:large_tire"...) ; nil sans pneu.
- 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()
true tant que la tête de forage est assemblée et tournée par le roulement.
- boolean
- true tant que la tête de forage est assemblée
local forage = peripheral.find("borehead_bearing")
print(forage.running(), forage.active())Voir aussi borehead_bearing.active()
forage.active()
true pendant que la foreuse creuse : assemblée, en rotation, ni calée ni en train de ralentir.
- boolean
- true pendant que la foreuse creuse
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.
- 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 :
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()
true pendant que la tête de forage ralentit, après un disassemble() ou un clic, avant de redevenir des blocs.
- boolean
- true pendant que la foreuse ralentit avant d'être défaite
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é.
- string|nil
- pourquoi la foreuse n'a pas pu s'assembler, en anglais ; nil si elle a pu
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.
- 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()
Ralentit la tête de forage, puis la remet en blocs, comme un clic. borehead_bearing.stopping() vaut true pendant ce temps.
- 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.
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)
endLe 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.