Create: Computing AgesDoc Brass
Périphériques

Diesel Generators

Les moteurs, brûleurs, fermenteurs, tours de distillation, pompes à pétrole et tourelles chimiques de Create: Diesel Generators, lus et pilotés par un ordinateur.

Il faut Create: Diesel Generators

Ces blocs appartiennent à Create: Diesel Generators. Sans ce mod, ils n'existent pas, et peripheral.find("diesel_engine") renvoie nil.

Create: Diesel Generators change le pétrole en rotation. Une pompe tire le pétrole du sol, une tour de distillation le sépare en diesel et en essence, un couvercle de bassin ou un fermenteur de masse produit de l'éthanol, et des moteurs diesel brûlent ces carburants pour entraîner un réseau de Create. Un ordinateur relié à ces blocs surveille chaque étape de la chaîne (carburant restant, chaleur, avancement, pétrole restant dans le chunk) et fait ce que ferait un joueur : il démarre, ralentit et arrête les moteurs, règle leur sens de rotation, ouvre un couvercle de bassin, vise avec une tourelle chimique et la fait tirer.

Bloc (en jeu)type de périphériquece qu'il lit ou règle
Moteur dieseldiesel_enginecarburant, accélérateur, rotation fournie, sens de rotation
Moteur diesel modulairemodular_diesel_enginela même chose, pour tout le moteur
Moteur diesel énormehuge_diesel_enginela même chose, pour l'arbre qu'il entraîne
Brûleurburnerchaleur, flamme, vanne, redstone
Couvercle de bassinbasin_lidfermentation et son avancement ; ouvre et ferme le couvercle
Fermenteur de massebulk_fermenterfermentation, son avancement, la chaleur dessous
Réservoir de distillationdistillation_tankdistillation, son avancement, la chaleur, sorties pleines
Trou de pompepumpjack_holele pétrole restant dans le chunk, le tuyau, le pétrole qu'il contient
Tourelle chimiquechemical_turretoù elle vise ; la tourne et la fait tirer

Contre l'ordinateur, un bloc s'appelle par sa face ("left"...) ; sur un Câble de données (Mini-ordinateur et plus récents), il reçoit un nom comme diesel_engine@12,64,-30. peripheral.find veut le type exact : peripheral.find("diesel_engine") ne trouve ni moteur modulaire ni moteur énorme. Un bloc qui fait partie d'un ensemble (un segment de moteur modulaire, n'importe quel bloc d'un fermenteur de masse ou d'une tour de distillation) répond pour tout l'ensemble.

Brass
local moteur = peripheral.find("diesel_engine")
local f = moteur.fuel()
print(moteur.generated_speed() .. " tr/min, " .. f.amount .. " mB de carburant")

Chaque méthode relit le bloc quand on l'appelle. Quand le bloc a disparu, l'appel arrête le programme avec son nom suivi de removed (diesel engine removed, modular diesel engine removed, huge diesel engine removed, burner removed, basin lid removed, bulk fermenter removed, distillation tank removed, pumpjack hole removed, chemical turret removed) ; quand son chunk n'est pas chargé, avec peripheral is not loaded. Un bloc multiple qui n'est pas assemblé l'arrête avec the modular diesel engine is not formed (ou the bulk fermenter, the distillation tank). Avec une autre version du mod, une méthode peut l'arrêter avec this version of Create: Diesel Generators has no ....

Aussi des blocs cinétiques et des réservoirs. Le moteur diesel, chaque segment d'un moteur diesel modulaire, le brûleur et la tourelle chimique sont des blocs cinétiques de Create, avec en plus les méthodes de Blocs cinétiques de Create (le couvercle de bassin aussi, même s'il ne tourne jamais). Leur speed() est la vitesse à laquelle tourne le bloc, 0 sur un réseau surchargé, là où generated_speed() est ce que donne le moteur ; capacity() est ce que tout le réseau peut fournir, là où stress_capacity() est la part du moteur lui-même. Le moteur diesel énorme n'est pas un bloc cinétique : le rotor alimenté qu'il entraîne en est un. Les blocs qui contiennent des fluides ont tank.tanks() (Réservoirs), mais seulement par les faces où le mod laisse entrer les fluides : l'entrée de carburant d'un moteur, toutes les faces du brûleur sauf le dessus, le dessous de la tourelle, les côtés du trou de pompe où se branche un tuyau. C'est pourquoi les moteurs ont fuel() et le trou de pompe stored() : ils lisent le réservoir quelle que soit la face. Le fermenteur de masse est aussi un inventaire (Inventaires) et un réservoir sur toutes ses faces, et chaque étage d'une tour de distillation est un réservoir qui contient son propre fluide.

Méthodes
moteur.active()true tant que le moteur tourne : il a du carburant, la redstone ne l'arrête pas, et son réseau n'est pas surchargé. Un moteur diesel énorme a aussi besoin de son rotor alimenté. Les trois moteurs l'ont.
moteur.fuel()Le réservoir du moteur, comme une entrée de tank.tanks() : fluid est l'identifiant du fluide ("createdieselgenerators:diesel"), nil s'il est vide ; amount et capacity sont en mB. Un moteur diesel et un moteur diesel modulaire entier contiennent 1000 mB, un moteur diesel énorme 100 mB. Cette méthode marche quelle que soit la face qui touche l'ordinateur ou le câble, alors que tanks() n'existe que sur l'entrée de carburant.
moteur.throttle()Le régime du moteur, réglé par la redstone : (15 - signal) / 15, arrondi à 3 décimales. Sans signal on lit 1, avec un signal de 5, 0.667, avec 15, 0. Quand le serveur a désactivé la commande analogique, on lit toujours 1 (un signal arrête alors le moteur sans changer cette valeur : lisez active()).
moteur.fuel_consumption()Avec les carburants par défaut, 1 mB par seconde à plein régime, 0,25 au plus bas (par segment pour un moteur modulaire) : un réservoir plein de 1000 mB dure environ 17 minutes. 0 tant que le moteur est arrêté : pas de carburant, un signal de redstone de 15, un réseau surchargé, ou un moteur énorme sans son rotor.
moteur.generated_speed()La vitesse à laquelle le moteur entraîne son réseau : la vitesse de son carburant (voir le tableau plus haut) multipliée par l'accélérateur, doublée par un turbocompresseur. Le signe est le sens de rotation, tel que Create le compte. Pour un moteur diesel énorme, c'est la vitesse de son rotor alimenté (la plus rapide des moteurs qui l'entraînent), et 0 tant que ce moteur-ci ne tourne pas.
moteur.stress_capacity()La part du moteur lui-même dans la capacité de son réseau, ce que les Lunettes d'ingénieur montrent comme la capacité qu'il fournit : au diesel et à plein régime, 6144 SU pour un moteur diesel, 8192 par segment d'un moteur modulaire, 16384 pour un moteur énorme. Ce n'est pas kinetic.capacity(), qui est ce que fournissent ensemble toutes les sources du réseau.
moteur.direction()Le sens réglé sur le panneau du moteur (Rotation Direction), comme le règle un joueur. Les trois moteurs l'ont.
moteur.set_direction(way)Règle le panneau du moteur, comme un joueur. Le changement se fait à la fin du tick, avec la dernière valeur demandée pendant ce tick. Tous les segments d'un moteur diesel modulaire le prennent, de même que tous les moteurs diesel énormes qui entraînent le même arbre. Tout autre texte arrête le programme avec bad argument #1 to 'set_direction' ("clockwise" or "counter_clockwise").
moteur.upgrade()L'amélioration qu'un joueur a posée sur le moteur. Un Silencieux de moteur le rend silencieux ; un Turbocompresseur de moteur double sa vitesse et sa capacité de contrainte (réglage serveur « Turbocharged Diesel Engine Speed Multiplier ») et ne se pose pas sur un moteur énorme. Un programme ne peut ni en poser ni en retirer.
bruleur.heat()La chaleur que le brûleur donne au bloc posé dessus, avec les noms des niveaux de chaleur de Create.
bruleur.lit()true tant que sa flamme brûle : il contient du carburant, et sa vanne est ouverte ou il reçoit de la redstone. Une petite flamme peut brûler alors que heat() lit "none" : elle ne chauffe alors rien.
bruleur.valve()L'ouverture de la vanne du brûleur. Un brûleur neuf commence à 0.2. Un arbre à 64 tr/min la fait passer de fermée à grande ouverte en 4 secondes environ.
bruleur.signal()Le signal de redstone le plus fort autour du brûleur. N'importe quel signal, même 1, le fait brûler plus fort que sa vanne grande ouverte.
couvercle.running()true tant qu'une recette tourne sous le couvercle fermé.
couvercle.progress()lua print(math.floor(couvercle.progress() * 100) .. " %")
couvercle.open()lua print(couvercle.open())
couvercle.set_open(open)Ouvre ou ferme le couvercle, comme un clic droit. Le changement se fait à la fin du tick. L'ouvrir arrête la fermentation (la fournée recommence une fois refermé). Le couvercle reste comme le programme l'a laissé jusqu'à ce que le signal de redstone autour de lui change. Autre chose que true ou false arrête le programme avec bad argument #1 to 'set_open' (boolean expected, got number) (ou le type donné).
f.running()lua local f = peripheral.find("bulk_fermenter") print(f.running(), f.progress(), f.heat())
f.progress()lua print(math.floor(f.progress() * 100) .. " %")
f.heat()Le plus chaud des blocs sous son étage du bas, avec les noms des niveaux de chaleur de Create (voir burner.heat()). Une recette qui demande de la chaleur attend tant qu'elle est trop basse.
tour.running()lua local tour = peripheral.find("distillation_tank") print(tour.running(), tour.progress())
tour.progress()lua print(math.floor(tour.progress() * 100) .. " %")
tour.heat()Le plus chaud des blocs sous l'étage du bas. Le pétrole demande "fading" ou plus chaud ; "seething" donne plus, et plus vite.
tour.full()true tant qu'un étage au-dessus n'a pas la place pour sa part de la fournée : la tour attend, son avancement figé, jusqu'à ce qu'on vide cet étage.
trou.oil()Le pétrole restant dans le chunk, tel que le trou l'a lu au dernier coup de pompe : les Lunettes d'ingénieur montrent le même nombre. math.huge pour un chunk qui ne s'épuise jamais, nil tant que la pompe n'a jamais pompé.
trou.connected()true quand une colonne continue de tuyaux à fluide descend du trou jusqu'à la bedrock. Le trou le vérifie une fois par seconde. Sans elle, la pompe ne pompe rien.
trou.pipe_length()lua print(trou.pipe_length() .. " blocs de profondeur")
trou.stored()Le réservoir du trou lui-même (8000 mB), comme une entrée de tank.tanks(). Cette méthode marche par n'importe quelle face, alors que tanks() n'existe que sur les côtés où se branche un tuyau.
tourelle.horizontal_rotation()L'angle qu'on a demandé à la tourelle, pas celui où elle pointe tant qu'elle tourne encore. De 0 à 359 quand un programme l'a réglé ; un joueur ou un mob qui la contrôle peut laisser n'importe quel angle, prenez-le donc % 360.
tourelle.vertical_rotation()lua print(tourelle.vertical_rotation())
tourelle.set_horizontal_rotation(degrees)Tourne la tourelle vers cet angle : elle commence à tourner à son tick suivant. Tout nombre entier convient, pris modulo 360 (-90 donne 270). Un nombre à virgule arrête le programme avec bad argument #1 to 'set_horizontal_rotation' (number has no integer representation). Un joueur ou un mob qui contrôle la tourelle vise à la place du programme.
tourelle.set_vertical_rotation(degrees)lua tourelle.set_vertical_rotation(-20) -- lève le canon de 20 degrés
tourelle.spray()Une giclée au tick suivant de la tourelle, là où pointe alors le canon : attendez d'abord on_target(). Elle renvoie false quand la tourelle ne peut pas tirer, sa roue dentée arrêtée ou son réservoir vide. Pour un long jet, donnez-lui plutôt de la redstone.
tourelle.on_target()Le test que fait la tourelle elle-même avant qu'un mob sur son siège ne tire. Une tourelle qui balaie un arc, une giclée tous les 15 degrés :
tourelle.controlled()true tant qu'un joueur la contrôle (jusqu'à ce qu'il s'accroupisse ou s'éloigne de plus de 3 blocs), ou tant qu'un mob est assis sur un Siège à côté d'elle. Leur visée remplace alors les angles du programme (celle d'un mob, tant qu'il a une cible).

Moteurs diesel

Les trois moteurs brûlent un carburant liquide et entraînent un réseau de Create. Tous trois ont les méthodes ci-dessous.

  • Moteur diesel : un seul bloc, un réservoir de 1000 mB. Son entrée de carburant est sa face du dessous quand il est couché, deux de ses faces latérales quand il est debout.
  • Moteur diesel modulaire : des segments posés en ligne (jusqu'à 21) forment un seul moteur, mené par l'un d'eux, son contrôleur. Il tourne à la vitesse d'un seul segment, mais fournit la capacité de contrainte de tous et brûle le carburant de tous, dans un seul réservoir de 1000 mB. Le carburant entre par le dessus d'un segment (le tuyau du dessus, qu'une clé retire). N'importe quel segment peut être enveloppé : les méthodes lisent le contrôleur.
  • Moteur diesel énorme : il entraîne un arbre posé deux blocs devant lui, en travers de son axe, qui devient un rotor alimenté ; plusieurs moteurs énormes peuvent entraîner le même arbre. Son réservoir contient 100 mB et prend le carburant par toutes ses faces sauf l'avant et l'arrière.

Avec les carburants par défaut du mod (un pack de données peut les changer), à plein régime :

carburantMoteur dieselModulaire, par segmentÉnorme
diesel96 tr/min, 6144 SU96 tr/min, 8192 SU224 tr/min, 16384 SU
essence, biodiesel96 tr/min, 4096 SU96 tr/min, 6144 SU224 tr/min, 12288 SU
éthanol96 tr/min, 2048 SU96 tr/min, 3072 SU192 tr/min, 6144 SU
huile végétale74 tr/min, 2048 SU74 tr/min, 2560 SU192 tr/min, 4096 SU

Chacun brûle 1 mB par seconde à plein régime (un moteur modulaire, 1 mB par seconde et par segment).

La redstone sert d'accélérateur. Aucune méthode ne démarre ni n'arrête un moteur : comme un joueur, le programme lui donne de la redstone, avec rs.set quand il touche l'ordinateur, ou par une Liaison de redstone posée contre lui et pilotée avec link.set (voir link). Aux réglages par défaut, le signal le plus fort autour du moteur (autour de n'importe quel segment d'un moteur modulaire) règle son accélérateur : sans signal il tourne à plein régime, à 15 il s'arrête, et entre les deux il tourne moins vite, à (15 - signal) / 15. Si le serveur a désactivé le réglage « Engines controlled by analog lever », n'importe quel signal arrête le moteur à la place (et rien ne l'arrête quand « Engines disabled with redstone » est désactivé aussi).

Brass
rs.set("left", 15)  -- le moteur à gauche s'arrête
rs.set("left", 5)   -- tourne aux deux tiers de sa vitesse
rs.set("left", 0)   -- plein régime

Le moteur suit dès que la sortie de l'ordinateur change, à la fin du tick du programme.

#

moteur.active()

→ boolean

true tant que le moteur tourne : il a du carburant, la redstone ne l'arrête pas, et son réseau n'est pas surchargé. Un moteur diesel énorme a aussi besoin de son rotor alimenté. Les trois moteurs l'ont.

Renvoie
boolean
vrai tant que le moteur brûle du carburant et entraîne son réseau
Brass
local moteur = peripheral.find("diesel_engine")
if not moteur.active() then
  print("moteur arrêté : carburant, redstone ou surcharge")
end

Voir aussi diesel_engine.throttle() diesel_engine.generated_speed()

#

moteur.fuel()

→ table

Le réservoir du moteur, comme une entrée de tank.tanks() : fluid est l'identifiant du fluide ("createdieselgenerators:diesel"), nil s'il est vide ; amount et capacity sont en mB. Un moteur diesel et un moteur diesel modulaire entier contiennent 1000 mB, un moteur diesel énorme 100 mB. Cette méthode marche quelle que soit la face qui touche l'ordinateur ou le câble, alors que tanks() n'existe que sur l'entrée de carburant.

Renvoie
table
le carburant du moteur, {fluid =, amount =, capacity =}
Brass
local f = moteur.fuel()
local debit = moteur.fuel_consumption()
if debit > 0 then
  print("encore " .. math.floor(f.amount / debit) .. " s de carburant")
end

Voir aussi diesel_engine.fuel_consumption() tank.tanks()

#

moteur.throttle()

→ number

Le régime du moteur, réglé par la redstone : (15 - signal) / 15, arrondi à 3 décimales. Sans signal on lit 1, avec un signal de 5, 0.667, avec 15, 0. Quand le serveur a désactivé la commande analogique, on lit toujours 1 (un signal arrête alors le moteur sans changer cette valeur : lisez active()).

Renvoie
number
de 0 (arrêté par la redstone) à 1 (plein régime)

Le moteur tourne à sa pleine vitesse multipliée par l'accélérateur, et brûle 0.25 + 0.75 × accélérateur de son plein débit de carburant : la moitié de la vitesse coûte encore 62,5 % du carburant. Un moteur diesel et un moteur diesel modulaire gardent la même capacité de contrainte à tout accélérateur au-dessus de 0 ; un moteur diesel énorme en donne moins avec moins d'accélérateur.

Brass
print(math.floor(moteur.throttle() * 100) .. " % d'accélérateur")

Voir aussi diesel_engine.generated_speed() diesel_engine.fuel_consumption()

#

moteur.fuel_consumption()

→ number

Avec les carburants par défaut, 1 mB par seconde à plein régime, 0,25 au plus bas (par segment pour un moteur modulaire) : un réservoir plein de 1000 mB dure environ 17 minutes. 0 tant que le moteur est arrêté : pas de carburant, un signal de redstone de 15, un réseau surchargé, ou un moteur énorme sans son rotor.

Renvoie
number
le carburant que brûle le moteur en ce moment, en mB par seconde ; 0 quand il ne brûle rien

Quand le serveur a désactivé la commande analogique, un moteur diesel modulaire arrêté par la redstone continue de brûler son carburant (le mod fonctionne ainsi), et cette méthode le montre.

Brass
print(moteur.fuel_consumption() .. " mB/s")

Voir aussi diesel_engine.fuel() diesel_engine.throttle()

#

moteur.generated_speed()

→ number

La vitesse à laquelle le moteur entraîne son réseau : la vitesse de son carburant (voir le tableau plus haut) multipliée par l'accélérateur, doublée par un turbocompresseur. Le signe est le sens de rotation, tel que Create le compte. Pour un moteur diesel énorme, c'est la vitesse de son rotor alimenté (la plus rapide des moteurs qui l'entraînent), et 0 tant que ce moteur-ci ne tourne pas.

Renvoie
number
la vitesse que donne le moteur, en tr/min, négative dans l'autre sens ; 0 quand il n'en donne pas

Ce n'est pas speed() de Blocs cinétiques de Create, la vitesse à laquelle tourne le bloc, qui lit 0 sur un réseau surchargé.

Brass
print(moteur.generated_speed() .. " tr/min")

Voir aussi diesel_engine.direction() kinetic.speed()

#

moteur.stress_capacity()

→ number

La part du moteur lui-même dans la capacité de son réseau, ce que les Lunettes d'ingénieur montrent comme la capacité qu'il fournit : au diesel et à plein régime, 6144 SU pour un moteur diesel, 8192 par segment d'un moteur modulaire, 16384 pour un moteur énorme. Ce n'est pas kinetic.capacity(), qui est ce que fournissent ensemble toutes les sources du réseau.

Renvoie
number
la capacité de contrainte que le moteur fournit à son réseau en ce moment, en SU ; 0 quand il ne donne pas de rotation
Brass
local cap = moteur.capacity()
if cap > 0 then
  print(math.floor(moteur.stress_capacity() / cap * 100) .. " % de la capacité du réseau")
end

Voir aussi kinetic.capacity() diesel_engine.throttle()

#

moteur.direction()

→ string

Le sens réglé sur le panneau du moteur (Rotation Direction), comme le règle un joueur. Les trois moteurs l'ont.

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

Voir aussi diesel_engine.set_direction()

#

moteur.set_direction(way)

Règle le panneau du moteur, comme un joueur. Le changement se fait à la fin du tick, avec la dernière valeur demandée pendant ce tick. Tous les segments d'un moteur diesel modulaire le prennent, de même que tous les moteurs diesel énormes qui entraînent le même arbre. Tout autre texte arrête le programme avec bad argument #1 to 'set_direction' ("clockwise" or "counter_clockwise").

Paramètres
way string
"clockwise" ou "counter_clockwise"

Toutes les sources d'un réseau doivent tourner dans le même sens : changez aussi les autres.

Brass
moteur.set_direction("counter_clockwise")

Voir aussi diesel_engine.direction()

#

moteur.upgrade()

→ string|nil

L'amélioration qu'un joueur a posée sur le moteur. Un Silencieux de moteur le rend silencieux ; un Turbocompresseur de moteur double sa vitesse et sa capacité de contrainte (réglage serveur « Turbocharged Diesel Engine Speed Multiplier ») et ne se pose pas sur un moteur énorme. Un programme ne peut ni en poser ni en retirer.

Renvoie
string|nil
"silencer", "turbocharger", ou nil sans amélioration
Brass
if moteur.upgrade() == "turbocharger" then
  print("turbocompressé")
end

Brûleur

Le brûleur de Diesel Generators (pas le Brûleur à blaze de Create) brûle un carburant liquide pour chauffer ce qui est posé dessus : un Bassin, un fermenteur de masse, une tour de distillation. Son réservoir (100 mB) prend le carburant par toutes ses faces sauf le dessus. Un arbre règle sa vanne : tourner dans un sens l'ouvre, dans l'autre la ferme, et elle reste là où on l'a laissée. Un signal de redstone, quelle que soit sa force, le fait brûler plus fort qu'une vanne grande ouverte, et brûler son carburant bien plus vite (jusqu'à 20 mB par seconde, contre 2 avec la vanne grande ouverte).

Sa chaleur : (ouverture + 1) × la force du carburant, où l'ouverture est la vanne (de 0 à 1), ou 4 fois le signal de redstone quand c'est plus. À partir de 1,0 il est "smouldering", de 1,2 "fading", de 1,4 "kindled", de 1,8 "seething". La force des carburants par défaut : essence 1,1, éthanol 0,9, diesel 0,6, biodiesel et huile végétale 0,5. Au diesel, une vanne grande ouverte donne 1,2, assez pour une recette « chauffée » (fading ou plus chaud) ; une recette « surchauffée » demande seething, ce que donne la redstone.

Un programme règle la vanne par son arbre : il le fait tourner avec un Contrôleur de vitesse de rotation (kinetic.set_speed()) ou à travers un Embrayage qu'il commande en redstone, et l'arrête dès que valve() lit l'ouverture voulue.

#

bruleur.heat()

→ string

La chaleur que le brûleur donne au bloc posé dessus, avec les noms des niveaux de chaleur de Create.

Renvoie
string
"none", "smouldering", "fading", "kindled" ou "seething"
Brass
local bruleur = peripheral.find("burner")
print(bruleur.heat(), bruleur.lit())

Voir aussi burner.lit() burner.valve()

#

bruleur.lit()

→ boolean

true tant que sa flamme brûle : il contient du carburant, et sa vanne est ouverte ou il reçoit de la redstone. Une petite flamme peut brûler alors que heat() lit "none" : elle ne chauffe alors rien.

Renvoie
boolean
vrai tant que le brûleur brûle
Brass
if not bruleur.lit() then
  print("le brûleur est éteint")
end
#

bruleur.valve()

→ number

L'ouverture de la vanne du brûleur. Un brûleur neuf commence à 0.2. Un arbre à 64 tr/min la fait passer de fermée à grande ouverte en 4 secondes environ.

Renvoie
number
l'ouverture de la vanne, de 0 (fermée) à 1
Brass
print("ouverte à " .. math.floor(bruleur.valve() * 100) .. " %")

Voir aussi burner.signal()

#

bruleur.signal()

→ number

Le signal de redstone le plus fort autour du brûleur. N'importe quel signal, même 1, le fait brûler plus fort que sa vanne grande ouverte.

Renvoie
number
la puissance de redstone que reçoit le brûleur, de 0 à 15
Brass
print(bruleur.signal())

Voir aussi burner.valve()

Couvercle de bassin

Le couvercle de bassin se pose sur un Bassin de Create et fait fermenter ce que contient le bassin : du sucre et de la poudre d'os donnent de l'éthanol, par exemple. Il travaille tant qu'il est fermé. Un clic droit l'ouvre ou le ferme, un signal de redstone aussi (ouvert tant que le signal est là). L'ouvrir arrête la fermentation et perd la fournée : une fois refermé, il recommence à zéro.

#

couvercle.running()

→ boolean

true tant qu'une recette tourne sous le couvercle fermé.

Renvoie
boolean
vrai tant que le couvercle fait fermenter
Brass
local couvercle = peripheral.find("basin_lid")
print(couvercle.running(), couvercle.progress())

Voir aussi basin_lid.progress()

#

couvercle.progress()

→ number
Renvoie
number
l'avancement de la fournée, de 0 à 1 ; 0 quand il ne fait pas fermenter
Brass
print(math.floor(couvercle.progress() * 100) .. " %")
#

couvercle.open()

→ boolean
Renvoie
boolean
vrai tant que le couvercle est ouvert
Brass
print(couvercle.open())

Voir aussi basin_lid.set_open()

#

couvercle.set_open(open)

Ouvre ou ferme le couvercle, comme un clic droit. Le changement se fait à la fin du tick. L'ouvrir arrête la fermentation (la fournée recommence une fois refermé). Le couvercle reste comme le programme l'a laissé jusqu'à ce que le signal de redstone autour de lui change. Autre chose que true ou false arrête le programme avec bad argument #1 to 'set_open' (boolean expected, got number) (ou le type donné).

Paramètres
open boolean
true ouvre le couvercle, false le ferme
Brass
couvercle.set_open(false) -- le fermer : la fermentation reprend

Voir aussi basin_lid.open()

Fermenteur de masse

Le fermenteur de masse est un grand réservoir, jusqu'à 3 blocs de large et empilé en hauteur, qui fait fermenter objets et fluides comme un couvercle de bassin, mais en grand. Plus il est grand, plus il va vite : une fournée avance chaque tick de la racine carrée de largeur × hauteur, et se fait jusqu'à largeur × largeur fois d'un coup. Il prend sa chaleur des blocs posés sous lui, le plus chaud comptant. N'importe lequel de ses blocs peut être enveloppé : les méthodes lisent tout le fermenteur. C'est aussi un inventaire et un réservoir.

#

f.running()

→ boolean
Renvoie
boolean
vrai tant que le fermenteur fait fermenter
Brass
local f = peripheral.find("bulk_fermenter")
print(f.running(), f.progress(), f.heat())

Voir aussi bulk_fermenter.progress()

#

f.progress()

→ number
Renvoie
number
l'avancement de la fournée, de 0 à 1 ; 0 quand il ne fait pas fermenter
Brass
print(math.floor(f.progress() * 100) .. " %")
#

f.heat()

→ string

Le plus chaud des blocs sous son étage du bas, avec les noms des niveaux de chaleur de Create (voir burner.heat()). Une recette qui demande de la chaleur attend tant qu'elle est trop basse.

Renvoie
string
la chaleur sous le fermenteur, de "none" à "seething"
Brass
if f.heat() == "none" then
  print("aucune chaleur sous le fermenteur")
end

Tour de distillation

Un Contrôleur de distillation change des Réservoirs à fluide de Create en tour de distillation, faite de réservoirs de distillation (Distillation Tank, pas traduit en jeu) : des étages d'un bloc de haut, jusqu'à 3 blocs de large. Le pétrole entre dans l'étage du bas ; quand la tour est chauffée par en dessous, chaque fournée de 100 mB donne 50 mB de diesel à l'étage juste au-dessus et 50 mB d'essence au suivant, toutes les 3 secondes (75 + 75 mB toutes les 2 secondes quand la chaleur est seething). Chaque source de chaleur au niveau le plus haut sous l'étage du bas ajoute une fournée par cycle. L'étage du bas mène tout : n'importe quel bloc de la tour peut être enveloppé, les méthodes lisent l'étage du bas. Chaque étage est aussi un réservoir : tanks() sur un bloc d'un étage donne le fluide de cet étage.

#

tour.running()

→ boolean
Renvoie
boolean
vrai tant que la tour distille
Brass
local tour = peripheral.find("distillation_tank")
print(tour.running(), tour.progress())

Voir aussi distillation_tank.full()

#

tour.progress()

→ number
Renvoie
number
l'avancement de la fournée, de 0 à 1 ; 0 quand elle ne distille pas
Brass
print(math.floor(tour.progress() * 100) .. " %")
#

tour.heat()

→ string

Le plus chaud des blocs sous l'étage du bas. Le pétrole demande "fading" ou plus chaud ; "seething" donne plus, et plus vite.

Renvoie
string
la chaleur sous l'étage du bas, de "none" à "seething"
Brass
print(tour.heat())
#

tour.full()

→ boolean

true tant qu'un étage au-dessus n'a pas la place pour sa part de la fournée : la tour attend, son avancement figé, jusqu'à ce qu'on vide cet étage.

Renvoie
boolean
vrai quand un étage de sortie n'a pas la place pour la prochaine fournée
Brass
if tour.full() then print("Videz les sorties") end

Voir aussi distillation_tank.running()

Pompe à pétrole

Une pompe, bâtie au-dessus d'un trou de pompe, tire le pétrole d'un chunk à pétrole (un Détecteur de pétrole les trouve). Un tuyau doit descendre tout droit du trou jusqu'à la bedrock. Chaque coup de pompe prend du pétrole au chunk et le met dans le réservoir du trou (8000 mB), d'où des tuyaux l'emportent par les côtés du trou. Un chunk contient une quantité fixe et finit par s'épuiser ; certains chunks ne s'épuisent jamais.

#

trou.oil()

→ number|nil

Le pétrole restant dans le chunk, tel que le trou l'a lu au dernier coup de pompe : les Lunettes d'ingénieur montrent le même nombre. math.huge pour un chunk qui ne s'épuise jamais, nil tant que la pompe n'a jamais pompé.

Renvoie
number|nil
le pétrole restant dans le chunk, en mB ; math.huge s'il ne s'épuise jamais ; nil avant le premier coup de pompe
Brass
local trou = peripheral.find("pumpjack_hole")
local petrole = trou.oil()
if petrole == nil then
  print("pas encore pompé")
elseif petrole == math.huge then
  print("ce chunk ne s'épuise jamais")
else
  print("encore " .. math.floor(petrole / 1000) .. " seaux")
end

Voir aussi pumpjack_hole.connected()

#

trou.connected()

→ boolean

true quand une colonne continue de tuyaux à fluide descend du trou jusqu'à la bedrock. Le trou le vérifie une fois par seconde. Sans elle, la pompe ne pompe rien.

Renvoie
boolean
vrai quand le tuyau sous le trou atteint la bedrock
Brass
if not trou.connected() then
  print("le tuyau n'atteint pas la bedrock")
end

Voir aussi pumpjack_hole.pipe_length()

#

trou.pipe_length()

→ number
Renvoie
number
à combien de blocs plus bas se trouve la bedrock ; 0 tant que le tuyau ne l'atteint pas
Brass
print(trou.pipe_length() .. " blocs de profondeur")
#

trou.stored()

→ table

Le réservoir du trou lui-même (8000 mB), comme une entrée de tank.tanks(). Cette méthode marche par n'importe quelle face, alors que tanks() n'existe que sur les côtés où se branche un tuyau.

Renvoie
table
le pétrole dans le trou, {fluid =, amount =, capacity =}
Brass
print(trou.stored().amount .. " mB")

Tourelle chimique

La tourelle chimique projette le fluide de son réservoir (1000 mB, rempli par le dessous) : de l'eau, de la lave, un carburant, qu'un Briquet à essence posé sur la tourelle enflamme. Une roue dentée doit la faire tourner : sans rotation elle ne tire pas, et plus la roue tourne vite, plus elle tire loin. Tant qu'elle reçoit un signal de redstone, elle tire sans arrêt. Un joueur peut en prendre les commandes d'un clic droit, et un mob assis sur un Siège à côté d'elle vise les êtres vivants et tire.

Ses méthodes sont celles du périphérique ComputerCraft de la tourelle elle-même, plus on_target et controlled, ajoutées par Computing Ages.

Les angles. L'angle horizontal va de 0 à 359 : 0 est le nord, 90 l'ouest, 180 le sud, 270 l'est (ce ne sont pas les angles de l'écran F3). L'angle vertical va de -50 (canon levé au maximum) à 11 (baissé). Les deux sont des nombres entiers. Une fois l'angle demandé, la tourelle s'y tourne toute seule, par le plus court chemin, en comblant un cinquième de l'écart à chaque tick : même un demi-tour est atteint en une seconde environ. L'angle vers une cible se calcule avec la différence des coordonnées (cible moins tourelle) :

Brass
local function cap_vers(dx, dz)
  return math.floor(math.atan2(dx, dz) * 180 / math.pi + 180.5) % 360
end

print(cap_vers(0, -10)) -- nord
print(cap_vers(10, 0))  -- est
print(cap_vers(-5, 5))  -- sud-ouest
Écran
0
270
135
#

tourelle.horizontal_rotation()

→ number

L'angle qu'on a demandé à la tourelle, pas celui où elle pointe tant qu'elle tourne encore. De 0 à 359 quand un programme l'a réglé ; un joueur ou un mob qui la contrôle peut laisser n'importe quel angle, prenez-le donc % 360.

Renvoie
number
l'angle horizontal vers lequel tourne la tourelle, en degrés
Brass
local tourelle = peripheral.find("chemical_turret")
print(tourelle.horizontal_rotation(), tourelle.vertical_rotation())

Voir aussi chemical_turret.set_horizontal_rotation() chemical_turret.on_target()

#

tourelle.vertical_rotation()

→ number
Renvoie
number
l'angle du canon demandé, de -50 (levé) à 11 (baissé)
Brass
print(tourelle.vertical_rotation())

Voir aussi chemical_turret.set_vertical_rotation()

#

tourelle.set_horizontal_rotation(degrees)

Tourne la tourelle vers cet angle : elle commence à tourner à son tick suivant. Tout nombre entier convient, pris modulo 360 (-90 donne 270). Un nombre à virgule arrête le programme avec bad argument #1 to 'set_horizontal_rotation' (number has no integer representation). Un joueur ou un mob qui contrôle la tourelle vise à la place du programme.

Paramètres
degrees number
le nouvel angle horizontal, un nombre entier (0 nord, 90 ouest, 180 sud, 270 est)
Brass
tourelle.set_horizontal_rotation(270) -- face à l'est

Voir aussi chemical_turret.horizontal_rotation() chemical_turret.on_target()

#

tourelle.set_vertical_rotation(degrees)

Paramètres
degrees number
le nouvel angle du canon, un nombre entier, gardé entre -50 (levé) et 11 (baissé)
Brass
tourelle.set_vertical_rotation(-20) -- lève le canon de 20 degrés

Voir aussi chemical_turret.vertical_rotation()

#

tourelle.spray()

→ boolean

Une giclée au tick suivant de la tourelle, là où pointe alors le canon : attendez d'abord on_target(). Elle renvoie false quand la tourelle ne peut pas tirer, sa roue dentée arrêtée ou son réservoir vide. Pour un long jet, donnez-lui plutôt de la redstone.

Renvoie
boolean
vrai quand la tourelle peut tirer (sa roue dentée tourne et son réservoir contient du fluide)
Brass
while not tourelle.on_target() do sleep(0.1) end
if not tourelle.spray() then
  print("pas de rotation, ou le réservoir est vide")
end

Voir aussi chemical_turret.on_target()

#

tourelle.on_target()

→ boolean

Le test que fait la tourelle elle-même avant qu'un mob sur son siège ne tire. Une tourelle qui balaie un arc, une giclée tous les 15 degrés :

Renvoie
boolean
vrai une fois que la tourelle pointe à moins de 2 degrés des angles demandés
Brass
local tourelle = peripheral.find("chemical_turret")
local arc = {150, 165, 180, 195, 210, 195, 180, 165}
tourelle.set_vertical_rotation(-5)
while true do
  for _, cap in ipairs(arc) do
    tourelle.set_horizontal_rotation(cap)
    while not tourelle.on_target() do sleep(0.05) end
    tourelle.spray()
    sleep(0.3)
  end
end
#

tourelle.controlled()

→ boolean

true tant qu'un joueur la contrôle (jusqu'à ce qu'il s'accroupisse ou s'éloigne de plus de 3 blocs), ou tant qu'un mob est assis sur un Siège à côté d'elle. Leur visée remplace alors les angles du programme (celle d'un mob, tant qu'il a une cible).

Renvoie
boolean
vrai tant qu'un joueur ou un mob contrôle la tourelle
Brass
if tourelle.controlled() then
  print("quelqu'un d'autre est aux commandes")
end

Un moteur de secours pour la centrale

Un petit programme complet : une centrale garde un moteur diesel de secours à l'arrêt, et le démarre quand le réseau approche de sa limite. Le moteur touche la face gauche de l'ordinateur, qui le tient arrêté avec un signal de 15 ; l'ordinateur tourne sur le même réseau, donc l'arbre à son dos lit la charge (voir Blocs cinétiques de Create). Le moteur s'arrête de nouveau dès que les autres sources pourraient porter la charge sans lui.

Brass
local secours = peripheral.wrap("left")
local reseau = peripheral.wrap("back")
local DEMARRE, ARRETE = 0.9, 0.75   -- part de la capacité utilisée

rs.set("left", 15)                  -- arrêté pour commencer
local en_marche = false

while true do
  local utilise = reseau.stress()
  local cap = reseau.capacity()
  if en_marche then
    -- la charge que porteraient les autres sources sans le secours
    local autres = cap - secours.stress_capacity()
    if autres > 0 and utilise / autres < ARRETE then
      rs.set("left", 15)
      en_marche = false
    end
  elseif cap == 0 or utilise / cap > DEMARRE then
    rs.set("left", 0)
    en_marche = true
  end

  local f = secours.fuel()
  term.clear()
  term.set_cursor(1, 1)
  print("charge " .. math.floor(utilise) .. " / " .. math.floor(cap) .. " SU")
  print("secours " .. (secours.active() and "en marche" or "à l'arrêt"))
  print("carburant " .. f.amount .. " / " .. f.capacity .. " mB")
  if f.amount < 100 then
    print("Remplissez le moteur de secours !")
  end
  sleep(2)
end

Le moteur de secours doit tourner dans le même sens que les autres moteurs de la centrale (diesel_engine.set_direction()).