Périphériques

$\text{[math]}$ Machines de Create

Un Moteur créatif et un Contrôleur de vitesse de rotation réglés par programme, des compteurs lus directement, un Inverseur de rotation séquencé qui tourne à la demande, et un Colleur.

Certains blocs de Create font plus pour un ordinateur que tourner. Un Moteur créatif et un Contrôleur de vitesse de rotation acceptent une nouvelle vitesse, le Compteur de vitesse et le Stressomètre donnent leurs mesures, un Inverseur de rotation séquencé tourne de l'angle que le programme demande, et un Colleur sort ou rentre. Chacun a son propre type de périphérique :

Bloc (en jeu)	type de périphérique	ce qu'un programme en fait
Moteur créatif	`creative_motor`	lit et règle la vitesse qu'il produit
Contrôleur de vitesse de rotation	`speed_controller`	lit et règle la vitesse de sa sortie
Compteur de vitesse	`speedometer`	lit la vitesse de son arbre
Stressomètre	`stressometer`	lit le stress et la capacité de son réseau
Inverseur de rotation séquencé	`sequenced_gearshift`	fait tourner sa sortie d'un angle, ou avancer un piston de tant de blocs
Colleur	`sticker`	le fait sortir, rentrer, et vérifie ce qu'il tient

Brass

local moteur = peripheral.find("creative_motor")
moteur.set_generated_speed(128)

Méthodes

`moteur.generated_speed()`	La vitesse que produit le Moteur créatif : le nombre affiché sur son panneau de valeur.
`moteur.set_generated_speed(rpm)`	Règle la vitesse que produit le moteur, comme le fait la molette sur son panneau de valeur.
`regul.target_speed()`	La vitesse que le Contrôleur de vitesse de rotation donne à la grande roue dentée posée dessus : le nombre affiché sur son panneau de valeur.
`regul.set_target_speed(rpm)`	Règle la vitesse de sortie du contrôleur, comme le fait la molette sur son panneau de valeur.
`compteur.speed()`	À quelle vitesse tourne l'arbre du compteur : ce que montre son aiguille.
`jauge.stress()`	Le stress utilisé sur le réseau du Stressomètre, tel que l'affiche son cadran.
`jauge.capacity()`	La capacité du réseau du Stressomètre : ce que fournissent ses moteurs, roues à eau et moteurs à vapeur. Bon marché aussi.
`inverseur.rotate(degrees [, speed])`	Fait tourner la sortie de l'inverseur de cet angle, puis l'arrête : l'instruction « Tourner d'un angle de » de Create.
`inverseur.move(blocks [, speed])`	Déplace de tant de blocs un Piston mécanique, une Poulie à corde ou un Chariot de portique entraîné par l'inverseur : l'instruction « Tourner pour bouger piston/poulie/portique » de Create.
`inverseur.running()`	Indique si l'inverseur est occupé.
`colleur.extended()`	Indique si le Colleur est sorti.
`colleur.attached()`	Indique si le Colleur tient quelque chose : il est sorti, et le bloc devant lui est un bloc auquel il peut se coller. De l'air ou de l'eau devant lui donnent `false`.
`colleur.extend()`	Fait sortir le Colleur : désormais, le bloc devant lui se déplace avec lui.
`colleur.retract()`	Fait rentrer le Colleur : le bloc qu'il tenait est relâché.
`colleur.toggle()`	Le fait sortir s'il était rentré, rentrer s'il était sorti, comme une impulsion de redstone.

Installation

Les atteindre. Comme tout périphérique, un bloc posé contre l'ordinateur s'appelle par sa face ("left", "back"...), et un bloc posé contre un Câble de données (Mini-ordinateur et plus récents) reçoit un nom comme sequenced_gearshift@120,64,-35. Le plus simple est peripheral.find avec le type du tableau. Voir Périphériques.

Ils tournent aussi. Tous les blocs de cette page sauf le Colleur sont aussi des blocs cinétiques de Create, avec speed(), stress(), capacity() et overstressed() en plus de leurs propres méthodes. Leur type, et leur nom sur un câble, reste celui du tableau.

Les changements arrivent en fin de tick. Une nouvelle vitesse pour un moteur ou un contrôleur, ou un nouveau mouvement pour un inverseur, reconstruit le réseau cinétique de Create. L'ordinateur ne le fait pas sur-le-champ : il note la demande et l'applique à la fin du tick du programme, une fois par bloc, avec la dernière valeur demandée. Une boucle qui appelle set_generated_speed mille fois dans le même tick ne coûte au monde qu'une mise à jour. Deux conséquences :

une lecture juste après, dans le même tick, donne encore l'ancienne valeur : sleep(0.05) attend un tick ;
deux mouvements demandés à un inverseur dans le même tick ne s'additionnent pas : seul le dernier a lieu.

Le Colleur fait exception : il bouge tout de suite.

En cas d'échec. Quand le bloc est cassé ou remplacé, ses méthodes arrêtent le programme avec creative motor removed (speed controller removed, sequenced gearshift removed...). Quand son chunk n'est pas chargé : peripheral is not loaded.

Rotation

`moteur.generated_speed()`

→ number

La vitesse que produit le Moteur créatif : le nombre affiché sur son panneau de valeur.

Renvoie

number: la vitesse réglée sur le moteur, en tr/min, négative pour l'autre sens

C'est le réglage, pas une mesure. Pour savoir à quelle vitesse l'arbre tourne vraiment (0 tant que le réseau est surchargé), demandez moteur.speed(), le kinetic.speed() de tout bloc cinétique.

Brass

local moteur = peripheral.wrap("back")
print("moteur réglé sur " .. moteur.generated_speed() .. " tr/min")

Voir aussi creative_motor.set_generated_speed() kinetic.speed()

`moteur.set_generated_speed(rpm)`

Règle la vitesse que produit le moteur, comme le fait la molette sur son panneau de valeur.

Paramètres

rpm number: la nouvelle vitesse, un nombre entier de tr/min, négatif pour tourner dans l'autre sens

0 l'arrête, une vitesse négative l'inverse. Les valeurs au-delà de -256 et 256 y sont ramenées. La nouvelle vitesse reste dans le moteur après la fin du programme. Elle s'applique à la fin du tick. Un nombre à virgule arrête le programme avec bad argument #1 to 'set_generated_speed' (number has no integer representation) : arrondissez-le d'abord avec math.round.

Un banc d'essai qui fait tourner une nouvelle machine de plus en plus vite, deux secondes par palier, puis l'arrête :

Brass

local moteur = peripheral.find("creative_motor")
for tours = 16, 256, 16 do
  moteur.set_generated_speed(tours)
  print(tours .. " tr/min")
  sleep(2)
end
moteur.set_generated_speed(0)

Voir aussi creative_motor.generated_speed()

`regul.target_speed()`

→ number

La vitesse que le Contrôleur de vitesse de rotation donne à la grande roue dentée posée dessus : le nombre affiché sur son panneau de valeur.

Renvoie

number: la vitesse visée par le contrôleur, en tr/min, négative pour l'autre sens

La roue ne tourne à cette vitesse que si l'arbre d'entrée du contrôleur tourne. regul.speed() (de Blocs cinétiques de Create) lit l'entrée, pas la roue.

Brass

local regul = peripheral.wrap("right")
print("vitesse visée : " .. regul.target_speed() .. " tr/min")

Voir aussi speed_controller.set_target_speed()

`regul.set_target_speed(rpm)`

Règle la vitesse de sortie du contrôleur, comme le fait la molette sur son panneau de valeur.

Paramètres

rpm number: la nouvelle vitesse visée, un nombre entier de tr/min entre -256 et 256, négatif pour l'autre sens

Les règles sont celles du moteur : la vitesse est ramenée entre -256 et 256, en nombre entier seulement, appliquée à la fin du tick et gardée après la fin du programme. L'ancien kinetic.set_speed() fait la même chose sur un contrôleur et marche toujours.

Un Levier analogique à gauche règle la vitesse de la ligne, de 0 à 128 tr/min :

Brass

local regul = peripheral.wrap("right")
while true do
  local tours = math.round(rs.get("left") / 15 * 128)
  if tours ~= regul.target_speed() then
    regul.set_target_speed(tours)
  end
  sleep(0.5)
end

Voir aussi speed_controller.target_speed() kinetic.set_speed()

Compteurs

Le Compteur de vitesse et le Stressomètre affichent leurs mesures sur un cadran ; l'ordinateur obtient les mêmes nombres.

`compteur.speed()`

→ number

À quelle vitesse tourne l'arbre du compteur : ce que montre son aiguille.

Renvoie

number: la vitesse de l'arbre qui traverse le compteur, en tr/min, négative pour l'autre sens

Brass

local compteur = peripheral.find("speedometer")
rs.set("top", math.abs(compteur.speed()) < 32)   -- une lampe quand la ligne ralentit

`jauge.stress()`

→ number

Le stress utilisé sur le réseau du Stressomètre, tel que l'affiche son cadran.

Renvoie

number: le stress que consomment les machines du réseau, en us

Il donne le même nombre que kinetic.stress(), mais pour bien moins cher : le Stressomètre le connaît déjà, l'appel ne parcourt donc pas le réseau et ne coûte aucune instruction en plus, quelle que soit la taille de l'usine. Sur un Stressomètre relié à aucun réseau, il lit 0.

Voir aussi stressometer.capacity() kinetic.stress()

`jauge.capacity()`

→ number

La capacité du réseau du Stressomètre : ce que fournissent ses moteurs, roues à eau et moteurs à vapeur. Bon marché aussi.

Renvoie

number: le stress que les sources du réseau peuvent fournir, en us

Brass

local jauge = peripheral.find("stressometer")
local capacite = jauge.capacity()
if capacite > 0 then
  print(string.format("charge %d %%", math.floor(jauge.stress() / capacite * 100)))
else
  print("rien n'entraîne ce réseau")
end

Voir aussi stressometer.stress() kinetic.capacity()

Inverseur de rotation séquencé

Dans Create, un Inverseur de rotation séquencé exécute une liste d'instructions réglée dans son écran à chaque impulsion de redstone (Redstone et liaisons de Create). Un programme peut plutôt lui donner un mouvement à la fois, avec l'angle ou la distance voulus, puis attendre qu'il ait fini.

Les instructions de l'écran sont perdues

rotate et move remplacent la liste d'instructions de l'inverseur par une seule rotation (ou un seul déplacement) suivie d'une fin. Ce que vous aviez réglé dans son écran est effacé, définitivement. La nouvelle instruction reste dans l'inverseur : une impulsion de redstone plus tard rejoue ce dernier mouvement.

Entre deux mouvements, la sortie est immobile, comme celle d'un inverseur arrivé au bout de sa liste. L'arbre d'entrée doit tourner : l'inverseur transmet sa rotation à la sortie juste le temps de couvrir l'angle ou la distance.

`inverseur.rotate(degrees [, speed])`

Fait tourner la sortie de l'inverseur de cet angle, puis l'arrête : l'instruction « Tourner d'un angle de » de Create.

Paramètres

degrees number: de combien tourne la sortie, en degrés, un nombre entier (son signe est ignoré)
speed number facultatif: 1 la vitesse de l'entrée (par défaut), 2 deux fois plus vite, -1 et -2 pareil dans l'autre sens

Un Roulement mécanique sur la sortie fait tourner sa structure d'exactement autant : une porte qui pivote de 90 degrés, un plateau tournant qui avance d'un poste. Le sens vient de speed seul : -90 revient à 90. Les angles au-delà de 100000 y sont ramenés. Le mouvement démarre à la fin du tick.

Brass

local inverseur = peripheral.find("sequenced_gearshift")
inverseur.rotate(90)        -- un quart de tour

Toute autre valeur de speed arrête le programme avec bad argument #2 to 'rotate' (speed multiplier 1, 2, -1 or -2), et un angle à virgule avec number has no integer representation.

Voir aussi sequenced_gearshift.move() sequenced_gearshift.running()

`inverseur.move(blocks [, speed])`

Déplace de tant de blocs un Piston mécanique, une Poulie à corde ou un Chariot de portique entraîné par l'inverseur : l'instruction « Tourner pour bouger piston/poulie/portique » de Create.

Paramètres

blocks number: de combien de blocs avance le piston, la poulie ou le portique, un nombre entier (son signe est ignoré)
speed number facultatif: 1, 2, -1 ou -2, comme pour rotate

Le sens dépend de speed et de la façon dont la machine est construite : essayez une fois 1 et -1. Comme rotate, il remplace les instructions de l'écran et démarre à la fin du tick.

Brass

local inverseur = peripheral.find("sequenced_gearshift")
inverseur.move(4)          -- le piston pousse le mur de 4 blocs
sleep(10)
inverseur.move(4, -1)      -- puis le ramène

Voir aussi sequenced_gearshift.rotate() sequenced_gearshift.running()

`inverseur.running()`

→ boolean

Indique si l'inverseur est occupé.

Renvoie

boolean: true pendant que l'inverseur exécute un mouvement, false une fois au repos

Un mouvement demandé dans ce tick ne démarre qu'à sa fin : running() juste après rotate répond donc encore false. Attendez un tick avant de demander :

Brass

local inverseur = peripheral.find("sequenced_gearshift")
inverseur.rotate(180)
sleep(0.05)              -- le mouvement démarre à la fin du tick
while inverseur.running() do
  sleep(0.1)
end
print("demi-tour terminé")

Colleur

Un Colleur colle le bloc posé devant lui tant qu'il est sorti. Sur une structure animée (un piston, un roulement, un portique), ce bloc voyage alors avec lui, et reste sur place une fois le Colleur rentré. Dans Create, une impulsion de redstone le fait basculer ; un programme utilise les méthodes ci-dessous, qui agissent tout de suite, pas en fin de tick.

`colleur.extended()`

→ boolean

Indique si le Colleur est sorti.

Renvoie

boolean: true quand le Colleur est sorti

Brass

local colleur = peripheral.find("sticker")
print(colleur.extended())

Voir aussi sticker.attached()

`colleur.attached()`

→ boolean

Indique si le Colleur tient quelque chose : il est sorti, et le bloc devant lui est un bloc auquel il peut se coller. De l'air ou de l'eau devant lui donnent false.

Renvoie

boolean: true quand le Colleur est sorti et collé à un bloc

Brass

local colleur = peripheral.find("sticker")
colleur.extend()
if not colleur.attached() then
  print("rien à prendre")
end

`colleur.extend()`

→ boolean

Fait sortir le Colleur : désormais, le bloc devant lui se déplace avec lui.

Renvoie

boolean: true quand le Colleur est sorti, false s'il l'était déjà

Voir aussi sticker.retract() sticker.toggle()

`colleur.retract()`

→ boolean

Fait rentrer le Colleur : le bloc qu'il tenait est relâché.

Renvoie

boolean: true quand le Colleur est rentré, false s'il l'était déjà

Voir aussi sticker.extend() sticker.toggle()

`colleur.toggle()`

→ boolean

Le fait sortir s'il était rentré, rentrer s'il était sorti, comme une impulsion de redstone.

Renvoie

boolean: true quand le Colleur a bougé

Exemples

Une ligne qui ralentit avant la surcharge

Un Contrôleur de vitesse de rotation entraîne une rangée de presses mécaniques, et un Stressomètre est posé sur le même réseau. Quand la charge dépasse 90 %, le programme ralentit la ligne de 16 tr/min ; sous 70 %, il la fait réaccélérer, jusqu'à 128 tr/min. Les presses ne s'arrêtent jamais sur une surcharge : elles tournent juste un peu moins vite quand le réseau est chargé.

Brass

local regul = peripheral.find("speed_controller")
local jauge = peripheral.find("stressometer")
local MAX = 128
local tours = MAX
regul.set_target_speed(tours)
while true do
  local capacite = jauge.capacity()
  if capacite > 0 then
    local charge = jauge.stress() / capacite
    if charge > 0.9 and tours > 16 then
      tours = tours - 16
    elseif charge < 0.7 and tours < MAX then
      tours = tours + 16
    end
    regul.set_target_speed(tours)
    print(string.format("charge %d %%, presses à %d tr/min", math.floor(charge * 100), tours))
  end
  sleep(2)
end

La recette Protection contre la surcharge protège toute une usine avec les méthodes génériques de Blocs cinétiques de Create.

Aller chercher un bloc avec un Colleur

Un Piston mécanique collant porte un Colleur sur sa tête et il est entraîné par un Inverseur de rotation séquencé. Un Câble de données longe le trajet du piston, pour que l'ordinateur atteigne le Colleur partout où il s'arrête (son nom change avec sa position : le programme le cherche donc à nouveau à chaque fois). Le piston sort de 3 blocs, le Colleur attrape le bloc qu'il rencontre, et le piston le ramène.

Brass

local inverseur = peripheral.find("sequenced_gearshift")

local function attendre_piston()
  sleep(0.05)
  while inverseur.running() do
    sleep(0.1)
  end
  sleep(0.5)   -- le piston repose ses blocs
end

inverseur.move(3)
attendre_piston()
local colleur = peripheral.find("sticker")
colleur.extend()
if colleur.attached() then
  inverseur.move(3, -1)
  attendre_piston()
  peripheral.find("sticker").retract()
  print("bloc livré")
else
  colleur.retract()
  print("rien à rapporter")
end

attendre_piston a le droit d'utiliser inverseur, car c'est une variable locale du fichier, pas d'une autre fonction.

#Installation

#Rotation

moteur.generated_speed()

moteur.set_generated_speed(rpm)

regul.target_speed()

regul.set_target_speed(rpm)

#Compteurs

compteur.speed()

jauge.stress()

jauge.capacity()

#Inverseur de rotation séquencé

inverseur.rotate(degrees [, speed])

inverseur.move(blocks [, speed])

inverseur.running()

#Colleur

colleur.extended()

colleur.attached()

colleur.extend()

colleur.retract()

colleur.toggle()

#Exemples

#Une ligne qui ralentit avant la surcharge

#Aller chercher un bloc avec un Colleur

Installation

Rotation

`moteur.generated_speed()`

`moteur.set_generated_speed(rpm)`

`regul.target_speed()`

`regul.set_target_speed(rpm)`

Compteurs

`compteur.speed()`

`jauge.stress()`

`jauge.capacity()`

Inverseur de rotation séquencé

`inverseur.rotate(degrees [, speed])`

`inverseur.move(blocks [, speed])`

`inverseur.running()`

Colleur

`colleur.extended()`

`colleur.attached()`

`colleur.extend()`

`colleur.retract()`

`colleur.toggle()`

Exemples

Une ligne qui ralentit avant la surcharge

Aller chercher un bloc avec un Colleur