Create: Computing AgesDoc Brass
Périphériques

Create: New Age

Les moteurs, blocs d'énergie, blocs de chaleur et le réacteur nucléaire de Create: New Age, pilotés par un ordinateur : vitesses, énergie, températures et combustible.

Il faut Create: New Age

Les blocs de cette page appartiennent à Create: New Age. Sans ce mod, aucun de ces blocs n'existe, et peripheral.find("motor") renvoie nil.

Create: New Age apporte l'électricité et la chaleur à Create. Ses moteurs font tourner des arbres avec de l'énergie, ses bobines de générateur et ses balais de carbone tirent cette énergie de la rotation, des fils entre connecteurs électriques la transportent, des électriseurs en chargent des objets et des lampadaires la consomment. La chaleur, elle, passe de bloc en bloc : plaques solaires et tuyaux de chaleur la recueillent, des radiateurs la donnent aux chaudières, des moteurs Stirling la changent de nouveau en rotation, et un réacteur nucléaire en produit énormément. Un ordinateur règle la vitesse et la puissance des moteurs, suit l'énergie, et surveille les températures avant que quelque chose ne fonde ou n'explose.

Create: New Age n'est pas traduit en français : en jeu, ses blocs gardent leur nom anglais, indiqué entre parenthèses.

Bloc (nom en jeu)type de périphériquece qu'il lit ou règle
moteur basique, avancé ou renforcé (Basic, Advanced, Reinforced Motor)motorsa vitesse (réglable), s'il tourne, le stress qu'il fournit, l'énergie qu'il consomme, son mode de redstone
extension de moteur basique ou avancée (Basic, Advanced Motor Extension)motor_extensionle multiplicateur de stress de son moteur (réglable)
balais de carbone (Carbon Brushes)carbon_brushesl'énergie qu'ils recueillent des bobines de générateur
électriseur basique, avancé ou renforcé (Basic, Advanced, Reinforced Energiser)energiserson énergie, la charge de l'objet sous lui
connecteur électrique (Electrical Connector)electrical_connectorson mode (réglable), ses fils
lampadaire (Street Light)street_lightson niveau de lumière (réglable), la lumière qu'il donne
radiateur (Heater)heatertempérature, la chaleur qu'il donne à une chaudière
tuyau de chaleur (Heat Pipe)heat_pipetempérature, la chaleur qu'il gagne
pompe à chaleur (Heat Pump)heat_pumptempérature, la chaleur qu'elle pousse
plaque chauffante solaire basique ou avancée (Basic, Advanced Solar Heating Plate)solar_heating_platetempérature, la chaleur qu'elle produit
moteur Stirling (Stirling Engine)stirling_enginetempérature, la vitesse qu'il produit
barre de réacteur (Reactor Rod)reactor_rodtempérature, son combustible, si elle brûle
évent de chaleur de réacteur (Reactor Heat Vent)reactor_heat_venttempérature, la chaleur qu'il prend aux barres
accepteur de combustible de réacteur (Reactor Fuel Acceptor)reactor_fuel_acceptorses barres : combien, leur combustible, la plus chaude

Atteindre un bloc. Contre l'ordinateur, un bloc s'appelle par sa face ("left"...) ; sur un Câble de données (Mini-ordinateur et plus récents), il reçoit un nom comme motor@12,64,-30. peripheral.find("motor") donne le premier, peripheral.list("motor") les noms de tous.

Brass
local moteur = peripheral.find("motor")
print("niveau " .. moteur.tier() .. ", " .. moteur.speed() .. " tr/min, " .. moteur.energy_consumption() .. " FE/t")
Note

New Age donne à ses moteurs, balais de carbone et électriseurs un périphérique ComputerCraft. Ses méthodes sont toutes ici, sous les noms de ce mod : getTier() devient tier(), getOutput() s'appelle output(), getMaxEnergy() et getCurrentEnergy() s'appellent max_energy() et current_energy(). Les autres méthodes sont nouvelles.

Ce qui revient. Chaque appel relit le bloc : une valeur est toujours fraîche ; les nombres sont arrondis à 3 décimales. Quand quelque chose ne va pas, l'appel arrête le programme avec une erreur que vous pouvez rattraper avec pcall :

erreurquand
motor removedle bloc a été cassé ou remplacé depuis peripheral.wrap (son type, avec des espaces : heat pipe removed)
peripheral is not loadedle chunk du bloc n'est pas chargé
bad argument #1 to 'set_speed' (...)un mauvais argument : une vitesse de 0, un nombre à virgule, un mode inconnu
this version of Create: New Age has no getHeatvotre version de New Age n'a pas ce que lit la méthode (le nom à la fin)
Create: New Age error: ...le bloc lui-même a échoué en répondant

Quand un réglage agit. set_speed, set_multiplier, set_mode et set_light_level agissent à la fin du tick, comme une clé : un programme qui règle plusieurs fois le même bloc dans un tick garde la dernière valeur. set_inverted agit tout de suite.

Des méthodes génériques aussi. Plusieurs de ces blocs ont aussi les méthodes d'un type générique (voir Périphériques) :

  • Blocs cinétiques de Create : moteurs, balais de carbone, électriseurs et moteurs Stirling tournent, ils ont donc stress(), capacity() et overstressed(). Le speed() et le set_speed() propres au moteur cachent ceux du type cinétique : son speed() est la vitesse réglée sur le moteur, pas celle de son arbre (0 tant qu'il est arrêté). motor.active() dit s'il tourne.
  • Blocs d'énergie : New Age compte l'énergie en Forge Energy (FE, le ⚡ de ses infobulles), donc energy() et energy_capacity() lisent la réserve d'un moteur, de balais de carbone, d'un électriseur ou d'un lampadaire. Un connecteur électrique ne garde rien (il passe l'énergie à son réseau) : il répond 0 et une capacité énorme qui ne veut rien dire.
  • Inventaires : l'accepteur de combustible a trois emplacements pour le combustible, que count() et push() atteignent.
Méthodes
moteur.tier()Le modèle du moteur : son niveau fixe sa vitesse maximale, son stress et sa réserve. C'est le getTier() du périphérique ComputerCraft de New Age.
moteur.speed()La vitesse réglée sur le panneau du moteur, en tr/min, qu'il tourne ou non : un moteur arrêté par la redstone ou à court d'énergie renvoie quand même la vitesse à laquelle il tournera. Elle cache kinetic.speed(), la vitesse de l'arbre. Un moteur neuf est réglé à 16 tr/min.
moteur.set_speed(rpm)Règle la vitesse, comme une clé sur son panneau, et renvoie la valeur retenue : entre moins et plus la vitesse maximale du moteur (128 tr/min pour le basique, 256 pour l'avancé et le renforcé, par défaut). Le moteur la prend à la fin du tick. Son stress et sa consommation restent les mêmes à toute vitesse.
moteur.active()true tant que le moteur tourne : il a de l'énergie, et sa redstone le laisse tourner. false tant que la redstone l'arrête ou que sa réserve est vide.
moteur.stress_capacity()La capacité de stress que le moteur ajoute à son réseau en ce moment, en us : le stress de son niveau multiplié par le multiplicateur de son extension, à toute vitesse. Moins quand sa réserve se vide, 0 tant qu'il est arrêté. Le capacity() du type cinétique est la capacité de tout le réseau.
moteur.energy_consumption()L'énergie que le moteur a prise dans sa réserve au dernier tick, en FE : 15, 60 ou 240 FE par tick selon son niveau aux réglages par défaut, multipliés par le multiplicateur de son extension. 0 tant qu'il est arrêté. Avec energy(), elle dit combien de temps le moteur tourne sur sa seule réserve :
moteur.inverted()false par défaut : le moteur tourne sans redstone et s'arrête avec. true une fois inversé (par une clé ou par set_inverted(true)) : il ne tourne que tant qu'il reçoit un signal de redstone.
moteur.set_inverted(inverted)Choisit comment le moteur suit la redstone, comme un clic droit avec une clé, tout de suite. Un moteur inversé contre l'ordinateur tourne tant que l'ordinateur l'alimente :
ext.multiplier()Le multiplicateur réglé sur l'extension, en pourcentage : 100 donne au moteur son propre stress, 200 le double pour le double d'énergie. Une extension neuve est réglée à 100.
ext.set_multiplier(percent)Règle le multiplicateur, comme une clé sur son panneau, et renvoie la valeur retenue : de 1 à 200 % sur une extension basique, jusqu'à 800 % sur une avancée, par défaut (configuration serveur basicMotorExtensionMultiplier et advancedMotorExtensionMultiplier). Tout pourcentage entier convient, plus fin que les pas du panneau. Il agit à la fin du tick.
balais.output()L'énergie que les balais ont recueillie de leurs bobines au dernier tick, en FE : la ligne « Energy Output » des Lunettes d'ingénieur, et le getOutput() du périphérique ComputerCraft de New Age. 0 tant que les bobines sont immobiles.
connecteur.mode()"pull" quand le connecteur prend l'énergie du bloc sur lequel il est posé, "inert" quand il ne la prend pas. Un connecteur neuf est en mode inert.
connecteur.set_mode(mode)Règle le mode, comme une clé sur le connecteur, à la fin du tick ; le réseau regarde alors de nouveau qui donne de l'énergie et qui en prend. Un autre mot arrête le programme avec bad argument #1 to 'set_mode' (inert, pull).
connecteur.connections()Combien de fils partent du connecteur : 0 pour un connecteur seul, qui ne sert que son propre bloc.
electriseur.tier()Le modèle de l'électriseur : le getTier() du périphérique ComputerCraft de New Age.
electriseur.max_energy()10 000, 100 000 ou 1 000 000 FE selon son niveau : le getMaxEnergy() du périphérique ComputerCraft, le même nombre que energy_capacity().
electriseur.current_energy()L'énergie dans l'électriseur en ce moment : le getCurrentEnergy() du périphérique ComputerCraft, le même nombre que energy().
electriseur.running()true tant qu'un objet sous l'électriseur est en train d'être électrisé ou chargé. Il passe à false quand l'objet est terminé, ou une demi-seconde après son départ.
electriseur.progress()Pour une recette, le rapport entre l'énergie déjà mise et celle que demande toute la pile ; pour un objet qui contient de l'énergie, son remplissage. 0 tant que l'électriseur est inactif.
electriseur.energy_consumption()L'énergie que l'électriseur a mise dans l'objet au dernier tick, en FE : au plus 4, 16 ou 64 FE selon son niveau pour chaque tranche de 10 tr/min de son arbre, moins quand sa réserve baisse. 0 tant qu'il est inactif.
lampe.light_level()Le niveau réglé sur son panneau, de 0 à 15, qu'il ait de l'énergie ou non. Un lampadaire neuf est réglé à 15.
lampe.set_light_level(level)Règle le niveau, comme une clé sur son panneau, à la fin du tick. 0 éteint le lampadaire, qui ne brûle alors plus d'énergie. Des lampadaires qui ne s'allument que la nuit :
lampe.light()La lumière que donne le lampadaire en ce moment : son niveau tant qu'il a de l'énergie, 0 une fois sa réserve vide.
bloc.temperature()La température du bloc, telle que la montrent les Lunettes d'ingénieur. Les sept blocs de chaleur l'ont. La plupart la changent une fois par seconde ; une barre de réacteur qui brûle, à chaque tick.
bloc.max_temperature()La température au-delà de laquelle le bloc est détruit : 10 000 ˚T, ou 26 000 ˚T pour une barre de réacteur, multipliés par la configuration serveur overheatingMultiplier (1 par défaut). Au-delà, un bloc de chaleur se change en lave ; une barre de réacteur qui brûle explose et laisse du corium. nil quand le serveur désactive la surchauffe (overheatingMultiplier à -1). Les sept blocs de chaleur l'ont. Les Lunettes d'ingénieur écrivent la température en jaune dès 65 % de cette limite, en orange dès 75 %, en rouge dès 90 %.
radiateur.heat()Radiateur seulement. La chaleur qu'il donne à la chaudière ou au bassin au-dessus de lui, avec les mots d'un Brûleur à blaze. Une fois par seconde, il change sa chaleur en un niveau et consomme cette chaleur : au-dessus de 500 ˚T il est "seething" et en consomme 500, au-dessus de 400 "kindled" (400), de 100 "fading" (100), de 50 "smouldering" (50), en dessous "none" (configuration serveur boilerRequiredHeatMultiplier). Il ne reste donc "seething" que tant qu'il reçoit environ 500 ˚T par seconde. Une chaudière compte "fading", "kindled" et "seething" comme 1, 2 et 3 niveaux de chaleur, "smouldering" comme une chaleur passive.
plaque.generating()Tuyau de chaleur et plaque solaire seulement.
pompe.pumped()Pompe à chaleur seulement. Une fois par seconde, la pompe pousse toute sa chaleur dans le bloc de chaleur devant elle, autant que ce bloc peut encore en prendre, puis perd 4 ˚T de ce qui reste. La méthode renvoie ce qu'elle a poussé : 0 quand rien devant elle ne prend de chaleur.
stirling.generated_speed()Moteur Stirling seulement. Une fois par seconde, au-dessus de 100 ˚T le moteur en consomme 100 et tourne à 32 tr/min ; au-dessus de 50 ˚T, il en consomme 50 et tourne à 16 tr/min ; en dessous, il s'arrête. Il ne prend de la chaleur qu'au bloc sous lui, et fournit 512 us à 16 tr/min, 1 024 us à 32. Le speed() du type cinétique donne la vitesse de son arbre.
barre.fuel()Barre de réacteur seulement. Combien de temps la barre brûle encore, en secondes : jusqu'à 17 280 (4 h 48 min) une fois remplie par l'accepteur de combustible.
barre.active()Barre de réacteur seulement. true tant que la barre a du combustible : elle luit, chauffe et émet des radiations. Seule une barre qui brûle explose, quand elle surchauffe ou quand on la casse.
evt.extracting()Évent de chaleur de réacteur seulement. La chaleur que l'évent a prise à ses barres pendant la dernière seconde. Il prend à chaque barre autant qu'il peut en contenir, jusqu'à 10 000 ˚T dans l'évent : quand l'évent approche de 10 000 ˚T, il ne prend plus rien et les barres chauffent. Évacuez sa chaleur pour qu'il continue d'en prendre.
accepteur.rods()Les barres alignées à partir des faces de l'accepteur, telles qu'il les trouve lui-même (jusqu'à 32 par ligne). 0 veut dire qu'il n'alimente rien : vérifiez où il est posé.
accepteur.fuel()Le combustible de ses barres, en secondes : leur moyenne, qui est aussi ce que chacune contient, puisque l'accepteur répartit le combustible chaque seconde. 0 sans barre.
accepteur.temperature()La température de la plus chaude de ses barres : un seul appel surveille tout le réacteur, même sans barre à portée de l'ordinateur. 0 sans barre.

Moteurs

Un moteur fait tourner son arbre avec de l'énergie. Il en stocke (16 000 FE pour le basique, 64 000 pour l'avancé, 128 000 pour le renforcé) et fournit le même stress à toute vitesse : 512 us pour le basique, 2 048 pour l'avancé, 8 192 pour le renforcé, pour 15, 60 et 240 FE par tick, aux réglages par défaut (configuration serveur, section Motors). Il tourne jusqu'à 128 tr/min (basique) ou 256 tr/min (avancé et renforcé), dans un sens ou dans l'autre, jamais à 0. Quand sa réserve se vide, il fournit moins de stress, puis s'arrête.

La redstone l'arrête. Un moteur tourne sans redstone et s'arrête tant qu'il reçoit un signal. Un clic droit avec une clé inverse cela : il ne tourne plus que tant qu'il reçoit un signal. Un moteur contre l'ordinateur suit rs.set (voir rs).

L'extension. Une extension de moteur (Motor Extension) posée derrière un moteur (du côté opposé à son arbre, tournée dans le même sens) multiplie le stress du moteur, et sa consommation avec, par son multiplicateur : jusqu'à 200 % (basique) ou 800 % (avancée). Elle ajoute aussi 64 000 ou 256 000 FE à la réserve du moteur.

#

moteur.tier()

→ number

Le modèle du moteur : son niveau fixe sa vitesse maximale, son stress et sa réserve. C'est le getTier() du périphérique ComputerCraft de New Age.

Renvoie
number
1 basique, 2 avancé, 3 renforcé
Brass
local moteur = peripheral.find("motor")
local noms = {"basique", "avancé", "renforcé"}
print("moteur " .. noms[moteur.tier()])

Voir aussi motor.set_speed()

#

moteur.speed()

→ number

La vitesse réglée sur le panneau du moteur, en tr/min, qu'il tourne ou non : un moteur arrêté par la redstone ou à court d'énergie renvoie quand même la vitesse à laquelle il tournera. Elle cache kinetic.speed(), la vitesse de l'arbre. Un moteur neuf est réglé à 16 tr/min.

Renvoie
number
la vitesse réglée sur le moteur, en tr/min, négative dans l'autre sens ; jamais 0
Brass
local moteur = peripheral.find("motor")
if moteur.active() then
  print("tourne à " .. moteur.speed() .. " tr/min")
else
  print("arrêté, réglé à " .. moteur.speed() .. " tr/min")
end

Voir aussi motor.set_speed() motor.active()

#

moteur.set_speed(rpm)

→ number

Règle la vitesse, comme une clé sur son panneau, et renvoie la valeur retenue : entre moins et plus la vitesse maximale du moteur (128 tr/min pour le basique, 256 pour l'avancé et le renforcé, par défaut). Le moteur la prend à la fin du tick. Son stress et sa consommation restent les mêmes à toute vitesse.

Paramètres
rpm number
la nouvelle vitesse, un nombre entier de tr/min, négatif pour tourner dans l'autre sens, jamais 0
Renvoie
number
la vitesse retenue, dans les limites de la vitesse maximale du moteur
Brass
local moteur = peripheral.find("motor")
print(moteur.set_speed(64))
print(moteur.set_speed(-32))
print(moteur.set_speed(1000))

Sur un moteur basique aux réglages par défaut, cela affiche 64, -32 (dans l'autre sens) et 128 (sa vitesse maximale). Une vitesse de 0 arrête le programme avec bad argument #1 to 'set_speed' (a motor never turns at 0: stop it with redstone), un nombre à virgule avec bad argument #1 to 'set_speed' (number has no integer representation).

Voir aussi motor.speed() motor.tier()

#

moteur.active()

→ boolean

true tant que le moteur tourne : il a de l'énergie, et sa redstone le laisse tourner. false tant que la redstone l'arrête ou que sa réserve est vide.

Renvoie
boolean
true tant que le moteur tourne
Brass
local moteur = peripheral.find("motor")
if not moteur.active() and moteur.energy() == 0 then
  print("le moteur n'a plus d'énergie")
end

Voir aussi motor.speed() motor.inverted()

#

moteur.stress_capacity()

→ number

La capacité de stress que le moteur ajoute à son réseau en ce moment, en us : le stress de son niveau multiplié par le multiplicateur de son extension, à toute vitesse. Moins quand sa réserve se vide, 0 tant qu'il est arrêté. Le capacity() du type cinétique est la capacité de tout le réseau.

Renvoie
number
le stress que fournit le moteur en ce moment, en us ; 0 tant qu'il est arrêté
Brass
local moteur = peripheral.find("motor")
print(moteur.stress_capacity() .. " des " .. moteur.capacity() .. " us du réseau")

Voir aussi motor.energy_consumption() motor_extension.multiplier()

#

moteur.energy_consumption()

→ number

L'énergie que le moteur a prise dans sa réserve au dernier tick, en FE : 15, 60 ou 240 FE par tick selon son niveau aux réglages par défaut, multipliés par le multiplicateur de son extension. 0 tant qu'il est arrêté. Avec energy(), elle dit combien de temps le moteur tourne sur sa seule réserve :

Renvoie
number
l'énergie que le moteur a consommée au dernier tick, en FE ; 0 tant qu'il est arrêté
Brass
local moteur = peripheral.find("motor")
local conso = moteur.energy_consumption()
if conso > 0 then
  print("encore " .. math.floor(moteur.energy() / conso / 20) .. " s d'énergie")
end

Voir aussi motor.stress_capacity()

#

moteur.inverted()

→ boolean

false par défaut : le moteur tourne sans redstone et s'arrête avec. true une fois inversé (par une clé ou par set_inverted(true)) : il ne tourne que tant qu'il reçoit un signal de redstone.

Renvoie
boolean
true quand le moteur ne tourne qu'avec de la redstone
Brass
local moteur = peripheral.find("motor")
print(moteur.inverted())

Voir aussi motor.set_inverted()

#

moteur.set_inverted(inverted)

Choisit comment le moteur suit la redstone, comme un clic droit avec une clé, tout de suite. Un moteur inversé contre l'ordinateur tourne tant que l'ordinateur l'alimente :

Paramètres
inverted boolean
true pour ne tourner qu'avec de la redstone, false pour s'arrêter avec
Brass
local moteur = peripheral.wrap("left")
moteur.set_inverted(true)
rs.set("left", true)   -- tourne
sleep(10)
rs.set("left", false)  -- s'arrête

Voir aussi motor.inverted() motor.active()

Extensions de moteur

#

ext.multiplier()

→ number

Le multiplicateur réglé sur l'extension, en pourcentage : 100 donne au moteur son propre stress, 200 le double pour le double d'énergie. Une extension neuve est réglée à 100.

Renvoie
number
le multiplicateur de l'extension, en pourcentage
Brass
local ext = peripheral.find("motor_extension")
print(ext.multiplier() .. " %")

Voir aussi motor_extension.set_multiplier() motor.stress_capacity()

#

ext.set_multiplier(percent)

→ number

Règle le multiplicateur, comme une clé sur son panneau, et renvoie la valeur retenue : de 1 à 200 % sur une extension basique, jusqu'à 800 % sur une avancée, par défaut (configuration serveur basicMotorExtensionMultiplier et advancedMotorExtensionMultiplier). Tout pourcentage entier convient, plus fin que les pas du panneau. Il agit à la fin du tick.

Paramètres
percent number
le nouveau multiplicateur, un nombre entier de pour cent
Renvoie
number
le multiplicateur retenu, de 1 à 200 (basique) ou 800 (avancée)

Sous 100 %, le moteur fournit moins de stress et consomme moins : un programme peut économiser l'énergie pendant que les machines se reposent.

Brass
local ext = peripheral.find("motor_extension")
print(ext.set_multiplier(50))   -- moitié de stress, moitié d'énergie

Voir aussi motor_extension.multiplier()

Produire et transporter l'énergie

Balais de carbone. Des bobines de générateur (Generator Coil) entraînées par un arbre et entourées d'aimants produisent de l'énergie. Les balais de carbone la recueillent, sur 8 bobines au plus alignées avec eux (configuration serveur maxCoils), et la poussent dans les blocs autour d'eux : une machine, ou un connecteur électrique qui l'envoie dans les fils.

#

balais.output()

→ number

L'énergie que les balais ont recueillie de leurs bobines au dernier tick, en FE : la ligne « Energy Output » des Lunettes d'ingénieur, et le getOutput() du périphérique ComputerCraft de New Age. 0 tant que les bobines sont immobiles.

Renvoie
number
l'énergie que les balais ont recueillie au dernier tick, en FE
Brass
local balais = peripheral.find("carbon_brushes")
local prod = balais.output()
print(prod .. " FE/t, " .. prod * 20 .. " FE/s")

Les fils. Des connecteurs électriques reliés par des fils forment un réseau. Chaque connecteur donne de l'énergie au bloc sur lequel il est posé, quand ce bloc en accepte. En mode pull, il prend aussi l'énergie de ce bloc : c'est pour les batteries et les générateurs d'autres mods, qui ne poussent pas leur énergie d'eux-mêmes. En mode inert, il ne la prend pas. Un bloc qui pousse son énergie, comme des balais de carbone, alimente le réseau dans les deux modes.

#

connecteur.mode()

→ string

"pull" quand le connecteur prend l'énergie du bloc sur lequel il est posé, "inert" quand il ne la prend pas. Un connecteur neuf est en mode inert.

Renvoie
string
"pull" ou "inert"
Brass
local connecteur = peripheral.find("electrical_connector")
print(connecteur.mode())

Voir aussi electrical_connector.set_mode()

#

connecteur.set_mode(mode)

Règle le mode, comme une clé sur le connecteur, à la fin du tick ; le réseau regarde alors de nouveau qui donne de l'énergie et qui en prend. Un autre mot arrête le programme avec bad argument #1 to 'set_mode' (inert, pull).

Paramètres
mode string
"pull" ou "inert"

Un connecteur en mode pull sur une batterie est un interrupteur pour ce que donne la batterie : "inert" l'empêche d'alimenter le réseau (le réseau peut toujours la charger), "pull" la laisse donner de nouveau.

Brass
local connecteur = peripheral.find("electrical_connector")
connecteur.set_mode("inert")

Voir aussi electrical_connector.mode()

#

connecteur.connections()

→ number

Combien de fils partent du connecteur : 0 pour un connecteur seul, qui ne sert que son propre bloc.

Renvoie
number
le nombre de fils attachés au connecteur
Brass
for _, nom in ipairs(peripheral.list("electrical_connector")) do
  print(nom .. " : " .. peripheral.wrap(nom).connections() .. " fils")
end

Consommer l'énergie

Électriseur. Au-dessus d'un Dépôt ou d'un tapis roulant, avec de la rotation et de l'énergie, un électriseur (Energiser) électrise les objets sous lui : il les transforme selon leur recette d'électrisation, ou remplit les objets qui contiennent de l'énergie. Il stocke 10 000, 100 000 ou 1 000 000 FE selon son niveau, et met dans un objet 4, 16 ou 64 FE par tick pour chaque tranche de 10 tr/min (configuration serveur energiserSpeedMultiplier).

#

electriseur.tier()

→ number

Le modèle de l'électriseur : le getTier() du périphérique ComputerCraft de New Age.

Renvoie
number
1 basique, 2 avancé, 3 renforcé
Brass
local electriseur = peripheral.find("energiser")
print("niveau " .. electriseur.tier())
#

electriseur.max_energy()

→ number

10 000, 100 000 ou 1 000 000 FE selon son niveau : le getMaxEnergy() du périphérique ComputerCraft, le même nombre que energy_capacity().

Renvoie
number
l'énergie que l'électriseur peut stocker au plus, en FE
Brass
local electriseur = peripheral.find("energiser")
print("plein à " .. math.floor(electriseur.current_energy() / electriseur.max_energy() * 100) .. " %")

Voir aussi energiser.current_energy()

#

electriseur.current_energy()

→ number

L'énergie dans l'électriseur en ce moment : le getCurrentEnergy() du périphérique ComputerCraft, le même nombre que energy().

Renvoie
number
l'énergie que l'électriseur stocke en ce moment, en FE
Brass
local electriseur = peripheral.find("energiser")
print(electriseur.current_energy() .. " FE")

Voir aussi energiser.max_energy()

#

electriseur.running()

→ boolean

true tant qu'un objet sous l'électriseur est en train d'être électrisé ou chargé. Il passe à false quand l'objet est terminé, ou une demi-seconde après son départ.

Renvoie
boolean
true tant que l'électriseur travaille sur un objet
Brass
local electriseur = peripheral.find("energiser")
print(electriseur.running())

Voir aussi energiser.progress()

#

electriseur.progress()

→ number

Pour une recette, le rapport entre l'énergie déjà mise et celle que demande toute la pile ; pour un objet qui contient de l'énergie, son remplissage. 0 tant que l'électriseur est inactif.

Renvoie
number
l'avancement de l'objet, de 0 à 1 ; 0 quand l'électriseur est inactif
Brass
local electriseur = peripheral.find("energiser")
if electriseur.running() then
  print(math.floor(electriseur.progress() * 100) .. " %")
end

Voir aussi energiser.running()

#

electriseur.energy_consumption()

→ number

L'énergie que l'électriseur a mise dans l'objet au dernier tick, en FE : au plus 4, 16 ou 64 FE selon son niveau pour chaque tranche de 10 tr/min de son arbre, moins quand sa réserve baisse. 0 tant qu'il est inactif.

Renvoie
number
l'énergie mise dans l'objet au dernier tick, en FE ; 0 quand il est inactif
Brass
local electriseur = peripheral.find("energiser")
print(electriseur.energy_consumption() .. " FE/t à " .. electriseur.speed() .. " tr/min")

Lampadaire. Un lampadaire (Street Light) est aussi un connecteur : des fils s'y attachent. Il stocke 10 000 FE et brûle 1 FE par tick par niveau de lumière (configuration serveur streetLightCapacity et streetLightLevelExtraction). Sans énergie, il s'éteint.

#

lampe.light_level()

→ number

Le niveau réglé sur son panneau, de 0 à 15, qu'il ait de l'énergie ou non. Un lampadaire neuf est réglé à 15.

Renvoie
number
le niveau de lumière réglé sur le lampadaire, de 0 à 15
Brass
local lampe = peripheral.find("street_light")
print(lampe.light_level(), lampe.light())

Voir aussi street_light.set_light_level() street_light.light()

#

lampe.set_light_level(level)

Règle le niveau, comme une clé sur son panneau, à la fin du tick. 0 éteint le lampadaire, qui ne brûle alors plus d'énergie. Des lampadaires qui ne s'allument que la nuit :

Paramètres
level number
le nouveau niveau de lumière, un nombre entier, gardé entre 0 et 15
Brass
while true do
  local t = os.day_time()
  local niveau = (t >= 13000 and t < 23000) and 15 or 0
  for _, nom in ipairs(peripheral.list("street_light")) do
    peripheral.wrap(nom).set_light_level(niveau)
  end
  sleep(10)
end

Voir aussi street_light.light_level()

#

lampe.light()

→ number

La lumière que donne le lampadaire en ce moment : son niveau tant qu'il a de l'énergie, 0 une fois sa réserve vide.

Renvoie
number
la lumière que donne le lampadaire en ce moment, de 0 à 15
Brass
local lampe = peripheral.find("street_light")
if lampe.light_level() > 0 and lampe.light() == 0 then
  print("le lampadaire n'a plus d'énergie")
end

Voir aussi street_light.light_level()

Chaleur

New Age compte la chaleur en ˚T. Chaque bloc de chaleur a une température, et une fois par seconde il la partage avec les blocs de chaleur qui le touchent : tous prennent la moyenne, et la chaleur se répand ainsi le long des tuyaux, de l'endroit où elle est produite à celui où elle sert. Certaines faces restent à l'écart : le dessus d'un radiateur et d'une plaque solaire, toutes les faces d'un moteur Stirling sauf le dessous. Une pompe à chaleur prend la chaleur par ses autres faces et la pousse par l'avant.

  • Produite par les plaques solaires au soleil, par les tuyaux de chaleur posés sur une source de chaleur, et par le réacteur à travers ses évents.
  • Consommée par les radiateurs, qui chauffent une chaudière ou un bassin comme un Brûleur à blaze, et par les moteurs Stirling, qui la changent en rotation.

Trop chaud. Au-delà de son max_temperature(), un bloc de chaleur se change en lave, et une barre de réacteur qui brûle explose. Les sept blocs de chaleur ont temperature() et max_temperature() ; chacun a aussi ses propres méthodes :

Blocses propres méthodes
radiateurheat_block.heat()
tuyau de chaleur, plaque solaireheat_block.generating()
pompe à chaleurheat_block.pumped()
moteur Stirlingheat_block.generated_speed()
barre de réacteurheat_block.fuel(), heat_block.active()
évent de chaleur de réacteurheat_block.extracting()
#

bloc.temperature()

→ number

La température du bloc, telle que la montrent les Lunettes d'ingénieur. Les sept blocs de chaleur l'ont. La plupart la changent une fois par seconde ; une barre de réacteur qui brûle, à chaque tick.

Renvoie
number
la température du bloc, en ˚T
Brass
local bloc = peripheral.find("heat_pipe")
print("température " .. bloc.temperature())

Voir aussi heat_block.max_temperature()

#

bloc.max_temperature()

→ number|nil

La température au-delà de laquelle le bloc est détruit : 10 000 ˚T, ou 26 000 ˚T pour une barre de réacteur, multipliés par la configuration serveur overheatingMultiplier (1 par défaut). Au-delà, un bloc de chaleur se change en lave ; une barre de réacteur qui brûle explose et laisse du corium. nil quand le serveur désactive la surchauffe (overheatingMultiplier à -1). Les sept blocs de chaleur l'ont. Les Lunettes d'ingénieur écrivent la température en jaune dès 65 % de cette limite, en orange dès 75 %, en rouge dès 90 %.

Renvoie
number|nil
la température au-delà de laquelle le bloc fond ou explose, en ˚T ; nil si la surchauffe est désactivée
Brass
local bloc = peripheral.find("heat_pipe")
local max = bloc.max_temperature()
if max then
  print(math.floor(bloc.temperature() / max * 100) .. " % de sa limite")
end

Voir aussi heat_block.temperature()

#

radiateur.heat()

→ string

Radiateur seulement. La chaleur qu'il donne à la chaudière ou au bassin au-dessus de lui, avec les mots d'un Brûleur à blaze. Une fois par seconde, il change sa chaleur en un niveau et consomme cette chaleur : au-dessus de 500 ˚T il est "seething" et en consomme 500, au-dessus de 400 "kindled" (400), de 100 "fading" (100), de 50 "smouldering" (50), en dessous "none" (configuration serveur boilerRequiredHeatMultiplier). Il ne reste donc "seething" que tant qu'il reçoit environ 500 ˚T par seconde. Une chaudière compte "fading", "kindled" et "seething" comme 1, 2 et 3 niveaux de chaleur, "smouldering" comme une chaleur passive.

Renvoie
string
"none", "smouldering", "fading", "kindled" ou "seething"
Brass
local radiateur = peripheral.find("heater")
if radiateur.heat() ~= "seething" then
  print("la chaudière manque de chaleur : " .. radiateur.heat())
end

Voir aussi heat_block.temperature()

#

plaque.generating()

→ number

Tuyau de chaleur et plaque solaire seulement.

Renvoie
number
la chaleur que le bloc a gagnée pendant la dernière seconde, en ˚T

Sur une plaque chauffante solaire, la chaleur qu'elle a produite pendant la dernière seconde : jusqu'à 20 ˚T (basique) ou 60 ˚T (avancée) sous un ciel dégagé, moins sous la pluie, au crépuscule ou à l'ombre, rien la nuit (configuration serveur solarPanelHeatMultiplier). Elle produit moins une fois plus chaude que 400 ˚T (basique) ou 1 200 ˚T (avancée) : une plaque dont personne ne prend la chaleur reste à ce niveau.

Sur un tuyau de chaleur, la chaleur qu'il a tirée pendant la dernière seconde du bloc sous lui, quand ce bloc chauffe une chaudière de Create (lave, Brûleur à blaze, radiateur) : 6 ˚T d'une chaleur passive comme la lave, 24 d'un Brûleur à blaze allumé, 42 d'un brûleur surchauffé, et plus rien une fois le tuyau à 900, 1 200 ou 1 800 ˚T. Moins le 1 ˚T que perd chaque tuyau par seconde (configuration serveur passivePipeHeatLoss) : un tuyau sur de la lave répond 5, un tuyau sans rien dessous -1.

Brass
local plaque = peripheral.find("solar_heating_plate")
print("le soleil donne " .. plaque.generating() .. " par seconde")
#

pompe.pumped()

→ number

Pompe à chaleur seulement. Une fois par seconde, la pompe pousse toute sa chaleur dans le bloc de chaleur devant elle, autant que ce bloc peut encore en prendre, puis perd 4 ˚T de ce qui reste. La méthode renvoie ce qu'elle a poussé : 0 quand rien devant elle ne prend de chaleur.

Renvoie
number
la chaleur que la pompe a poussée pendant la dernière seconde, en ˚T
Brass
local pompe = peripheral.find("heat_pump")
if pompe.pumped() == 0 and pompe.temperature() > 0 then
  print("la pompe est bloquée : rien devant elle ne prend sa chaleur")
end
#

stirling.generated_speed()

→ number

Moteur Stirling seulement. Une fois par seconde, au-dessus de 100 ˚T le moteur en consomme 100 et tourne à 32 tr/min ; au-dessus de 50 ˚T, il en consomme 50 et tourne à 16 tr/min ; en dessous, il s'arrête. Il ne prend de la chaleur qu'au bloc sous lui, et fournit 512 us à 16 tr/min, 1 024 us à 32. Le speed() du type cinétique donne la vitesse de son arbre.

Renvoie
number
la vitesse que produit le moteur, 0, 16 ou 32 tr/min
Brass
local stirling = peripheral.find("stirling_engine")
print(stirling.generated_speed() .. " tr/min")

Le réacteur nucléaire

Un réacteur est un groupe de barres de réacteur, alimentées par un accepteur de combustible et refroidies par des évents de chaleur. Aux réglages par défaut (les seuils suivent overheatingMultiplier) :

  • Les barres brûlent leur combustible, un tick de combustible par tick, et gagnent 30 ˚T par tick, 600 par seconde (configuration serveur ReactorRodHeat). Au-dessus de 16 000 ˚T, une barre perd 25 ˚T par tick (ReactorRodHeatLoss) : elle chauffe encore, plus lentement. Des barres côte à côte partagent leur chaleur environ toutes les 2 secondes. Une barre qui brûle sans que rien ne prenne sa chaleur atteint sa limite de 26 000 ˚T en deux minutes environ, et explose.
  • L'accepteur de combustible a trois emplacements pour du combustible nucléaire (Nuclear Fuel). Une fois par seconde, il trouve les barres alignées à partir de chacune de ses faces (jusqu'à 32 par ligne, configuration serveur maxRodsInDirection), les remplit depuis ses emplacements, jusqu'à 4 h 48 min de combustible chacune (345 600 ticks), et répartit le combustible pour qu'elles en aient toutes autant. Un combustible nucléaire brûle 24 minutes dans une barre (28 800 ticks), partagées entre toutes les barres.
  • Les évents de chaleur prennent la chaleur des barres alignées à partir de chacune de leurs faces, tant qu'ils contiennent moins de 10 000 ˚T, et la partagent avec les blocs de chaleur qui les touchent : des tuyaux de chaleur, qui la portent vers des radiateurs ou des moteurs Stirling.
#

barre.fuel()

→ number

Barre de réacteur seulement. Combien de temps la barre brûle encore, en secondes : jusqu'à 17 280 (4 h 48 min) une fois remplie par l'accepteur de combustible.

Renvoie
number
le combustible qui reste dans la barre, en secondes
Brass
local barre = peripheral.find("reactor_rod")
local s = barre.fuel()
print(string.format("%d min %02d s de combustible", math.floor(s / 60), math.floor(s % 60)))

Voir aussi reactor_fuel_acceptor.fuel()

#

barre.active()

→ boolean

Barre de réacteur seulement. true tant que la barre a du combustible : elle luit, chauffe et émet des radiations. Seule une barre qui brûle explose, quand elle surchauffe ou quand on la casse.

Renvoie
boolean
true tant que la barre brûle
Brass
local barre = peripheral.find("reactor_rod")
print(barre.active(), barre.temperature())

Voir aussi heat_block.fuel()

#

evt.extracting()

→ number

Évent de chaleur de réacteur seulement. La chaleur que l'évent a prise à ses barres pendant la dernière seconde. Il prend à chaque barre autant qu'il peut en contenir, jusqu'à 10 000 ˚T dans l'évent : quand l'évent approche de 10 000 ˚T, il ne prend plus rien et les barres chauffent. Évacuez sa chaleur pour qu'il continue d'en prendre.

Renvoie
number
la chaleur que l'évent a prise aux barres pendant la dernière seconde, en ˚T
Brass
local evt = peripheral.find("reactor_heat_vent")
print(evt.extracting() .. " prises, évent à " .. evt.temperature())
#

accepteur.rods()

→ number⚙ coût 6

Les barres alignées à partir des faces de l'accepteur, telles qu'il les trouve lui-même (jusqu'à 32 par ligne). 0 veut dire qu'il n'alimente rien : vérifiez où il est posé.

Renvoie
number
le nombre de barres que l'accepteur alimente
Brass
local accepteur = peripheral.find("reactor_fuel_acceptor")
print(accepteur.rods() .. " barres")

Voir aussi reactor_fuel_acceptor.fuel()

#

accepteur.fuel()

→ number⚙ coût 6

Le combustible de ses barres, en secondes : leur moyenne, qui est aussi ce que chacune contient, puisque l'accepteur répartit le combustible chaque seconde. 0 sans barre.

Renvoie
number
le combustible moyen de ses barres, en secondes ; 0 sans barre
Brass
local accepteur = peripheral.find("reactor_fuel_acceptor")
print(math.floor(accepteur.fuel() / 60) .. " min de combustible")

Voir aussi heat_block.fuel()

#

accepteur.temperature()

→ number⚙ coût 6

La température de la plus chaude de ses barres : un seul appel surveille tout le réacteur, même sans barre à portée de l'ordinateur. 0 sans barre.

Renvoie
number
la température de sa barre la plus chaude, en ˚T ; 0 sans barre
Brass
local accepteur = peripheral.find("reactor_fuel_acceptor")
if accepteur.temperature() > 20000 then
  print("Trop chaud !")
end

Voir aussi heat_block.max_temperature()

Une garde pour le réacteur

Un programme complet qui fait tourner un réacteur avec peu de combustible à la fois, pour qu'il s'éteigne peu après l'arrêt du combustible. L'accepteur de combustible est à gauche de l'ordinateur, un coffre de combustible nucléaire à droite, une lampe ou une cloche au-dessus. Chaque seconde, l'ordinateur lit le réacteur. Tant que les barres ont moins de 2 minutes de combustible, il met un combustible nucléaire dans l'accepteur ; à la moitié de la limite, il cesse de l'alimenter, et dès 75 % il donne l'alarme.

Les barres n'ont alors jamais beaucoup plus qu'un combustible nucléaire (24 minutes pour une barre, partagées entre toutes), au lieu de 4 h 48 min chacune quand un entonnoir garde l'accepteur plein. Si le coffre se vide ou si le programme s'arrête, le réacteur s'éteint de lui-même. La limite est celle d'une barre aux réglages par défaut ; lisez-la sur une barre avec heat_block.max_temperature() quand le serveur la change.

Brass
local accepteur = peripheral.wrap("left")
local coffre = peripheral.wrap("right")
local LIMITE = 26000   -- max_temperature() d'une barre de réacteur, réglages par défaut
local BAS = 120        -- secondes de combustible restantes avant d'en ajouter

while true do
  local chaud = accepteur.temperature()
  local reste = accepteur.fuel()
  local etat = "en marche"
  if chaud >= LIMITE * 0.5 then
    etat = "trop chaud : plus de combustible"
  elseif reste < BAS and accepteur.count() == 0 then
    if coffre.push("left", nil, 1) > 0 then
      etat = "combustible ajouté"
    else
      etat = "plus de combustible"
    end
  end
  rs.set("top", chaud >= LIMITE * 0.75)

  term.clear()
  term.set_cursor(1, 1)
  print("RÉACTEUR, " .. accepteur.rods() .. " barres")
  if chaud >= LIMITE * 0.75 then
    term.set_fg(term.colors.red)
  elseif chaud >= LIMITE * 0.5 then
    term.set_fg(term.colors.yellow)
  end
  print(string.format("barre la plus chaude %d / %d", math.floor(chaud), LIMITE))
  term.set_fg(term.colors.white)
  print(string.format("combustible %d min %02d s", math.floor(reste / 60), math.floor(reste % 60)))
  print(etat)
  sleep(1)
end

accepteur.count() et coffre.push viennent de Inventaires : l'accepteur ne prend que du combustible, le coffre ne devrait donc rien contenir d'autre.