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.
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érique | ce qu'il lit ou règle |
|---|---|---|
| moteur basique, avancé ou renforcé (Basic, Advanced, Reinforced Motor) | motor | sa 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_extension | le multiplicateur de stress de son moteur (réglable) |
| balais de carbone (Carbon Brushes) | carbon_brushes | l'énergie qu'ils recueillent des bobines de générateur |
| électriseur basique, avancé ou renforcé (Basic, Advanced, Reinforced Energiser) | energiser | son énergie, la charge de l'objet sous lui |
| connecteur électrique (Electrical Connector) | electrical_connector | son mode (réglable), ses fils |
| lampadaire (Street Light) | street_light | son niveau de lumière (réglable), la lumière qu'il donne |
| radiateur (Heater) | heater | température, la chaleur qu'il donne à une chaudière |
| tuyau de chaleur (Heat Pipe) | heat_pipe | température, la chaleur qu'il gagne |
| pompe à chaleur (Heat Pump) | heat_pump | température, la chaleur qu'elle pousse |
| plaque chauffante solaire basique ou avancée (Basic, Advanced Solar Heating Plate) | solar_heating_plate | température, la chaleur qu'elle produit |
| moteur Stirling (Stirling Engine) | stirling_engine | température, la vitesse qu'il produit |
| barre de réacteur (Reactor Rod) | reactor_rod | température, son combustible, si elle brûle |
| évent de chaleur de réacteur (Reactor Heat Vent) | reactor_heat_vent | température, la chaleur qu'il prend aux barres |
| accepteur de combustible de réacteur (Reactor Fuel Acceptor) | reactor_fuel_acceptor | ses 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.
local moteur = peripheral.find("motor")
print("niveau " .. moteur.tier() .. ", " .. moteur.speed() .. " tr/min, " .. moteur.energy_consumption() .. " FE/t")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 :
| erreur | quand |
|---|---|
motor removed | le bloc a été cassé ou remplacé depuis peripheral.wrap (son type, avec des espaces : heat pipe removed) |
peripheral is not loaded | le 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 getHeat | votre 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 doncstress(),capacity()etoverstressed(). Lespeed()et leset_speed()propres au moteur cachent ceux du type cinétique : sonspeed()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), doncenergy()etenergy_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épond0et une capacité énorme qui ne veut rien dire.Inventaires: l'accepteur de combustible a trois emplacements pour le combustible, quecount()etpush()atteignent.
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()
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.
- number
- 1 basique, 2 avancé, 3 renforcé
local moteur = peripheral.find("motor")
local noms = {"basique", "avancé", "renforcé"}
print("moteur " .. noms[moteur.tier()])Voir aussi motor.set_speed()
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.
- number
- la vitesse réglée sur le moteur, en tr/min, négative dans l'autre sens ; jamais 0
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")
endVoir aussi motor.set_speed() motor.active()
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.
rpmnumber- la nouvelle vitesse, un nombre entier de tr/min, négatif pour tourner dans l'autre sens, jamais 0
- number
- la vitesse retenue, dans les limites de la vitesse maximale du moteur
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()
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.
- boolean
- true tant que le moteur tourne
local moteur = peripheral.find("motor")
if not moteur.active() and moteur.energy() == 0 then
print("le moteur n'a plus d'énergie")
endVoir aussi motor.speed() motor.inverted()
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.
- number
- le stress que fournit le moteur en ce moment, en us ; 0 tant qu'il est arrêté
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()
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 :
- number
- l'énergie que le moteur a consommée au dernier tick, en FE ; 0 tant qu'il est arrêté
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")
endVoir aussi motor.stress_capacity()
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.
- boolean
- true quand le moteur ne tourne qu'avec de la redstone
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 :
invertedboolean- true pour ne tourner qu'avec de la redstone, false pour s'arrêter avec
local moteur = peripheral.wrap("left")
moteur.set_inverted(true)
rs.set("left", true) -- tourne
sleep(10)
rs.set("left", false) -- s'arrêteVoir aussi motor.inverted() motor.active()
Extensions de moteur
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.
- number
- le multiplicateur de l'extension, en pourcentage
local ext = peripheral.find("motor_extension")
print(ext.multiplier() .. " %")Voir aussi motor_extension.set_multiplier() motor.stress_capacity()
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.
percentnumber- le nouveau multiplicateur, un nombre entier de pour cent
- 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.
local ext = peripheral.find("motor_extension")
print(ext.set_multiplier(50)) -- moitié de stress, moitié d'énergieVoir 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()
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.
- number
- l'énergie que les balais ont recueillie au dernier tick, en FE
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()
"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.
- string
- "pull" ou "inert"
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).
modestring- "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.
local connecteur = peripheral.find("electrical_connector")
connecteur.set_mode("inert")Voir aussi electrical_connector.mode()
connecteur.connections()
Combien de fils partent du connecteur : 0 pour un connecteur seul, qui ne sert que son propre bloc.
- number
- le nombre de fils attachés au connecteur
for _, nom in ipairs(peripheral.list("electrical_connector")) do
print(nom .. " : " .. peripheral.wrap(nom).connections() .. " fils")
endConsommer 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()
Le modèle de l'électriseur : le getTier() du périphérique ComputerCraft de New Age.
- number
- 1 basique, 2 avancé, 3 renforcé
local electriseur = peripheral.find("energiser")
print("niveau " .. electriseur.tier())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().
- number
- l'énergie que l'électriseur peut stocker au plus, en FE
local electriseur = peripheral.find("energiser")
print("plein à " .. math.floor(electriseur.current_energy() / electriseur.max_energy() * 100) .. " %")Voir aussi energiser.current_energy()
electriseur.current_energy()
L'énergie dans l'électriseur en ce moment : le getCurrentEnergy() du périphérique ComputerCraft, le même nombre que energy().
- number
- l'énergie que l'électriseur stocke en ce moment, en FE
local electriseur = peripheral.find("energiser")
print(electriseur.current_energy() .. " FE")Voir aussi energiser.max_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.
- boolean
- true tant que l'électriseur travaille sur un objet
local electriseur = peripheral.find("energiser")
print(electriseur.running())Voir aussi energiser.progress()
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.
- number
- l'avancement de l'objet, de 0 à 1 ; 0 quand l'électriseur est inactif
local electriseur = peripheral.find("energiser")
if electriseur.running() then
print(math.floor(electriseur.progress() * 100) .. " %")
endVoir aussi energiser.running()
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.
- number
- l'énergie mise dans l'objet au dernier tick, en FE ; 0 quand il est inactif
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()
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.
- number
- le niveau de lumière réglé sur le lampadaire, de 0 à 15
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 :
levelnumber- le nouveau niveau de lumière, un nombre entier, gardé entre 0 et 15
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)
endVoir aussi street_light.light_level()
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.
- number
- la lumière que donne le lampadaire en ce moment, de 0 à 15
local lampe = peripheral.find("street_light")
if lampe.light_level() > 0 and lampe.light() == 0 then
print("le lampadaire n'a plus d'énergie")
endVoir 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 :
| Bloc | ses propres méthodes |
|---|---|
| radiateur | heat_block.heat() |
| tuyau de chaleur, plaque solaire | heat_block.generating() |
| pompe à chaleur | heat_block.pumped() |
| moteur Stirling | heat_block.generated_speed() |
| barre de réacteur | heat_block.fuel(), heat_block.active() |
| évent de chaleur de réacteur | heat_block.extracting() |
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.
- number
- la température du bloc, en ˚T
local bloc = peripheral.find("heat_pipe")
print("température " .. bloc.temperature())Voir aussi heat_block.max_temperature()
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 %.
- number|nil
- la température au-delà de laquelle le bloc fond ou explose, en ˚T ; nil si la surchauffe est désactivée
local bloc = peripheral.find("heat_pipe")
local max = bloc.max_temperature()
if max then
print(math.floor(bloc.temperature() / max * 100) .. " % de sa limite")
endVoir aussi heat_block.temperature()
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.
- string
- "none", "smouldering", "fading", "kindled" ou "seething"
local radiateur = peripheral.find("heater")
if radiateur.heat() ~= "seething" then
print("la chaudière manque de chaleur : " .. radiateur.heat())
endVoir aussi heat_block.temperature()
plaque.generating()
Tuyau de chaleur et plaque solaire seulement.
- 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.
local plaque = peripheral.find("solar_heating_plate")
print("le soleil donne " .. plaque.generating() .. " par seconde")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.
- number
- la chaleur que la pompe a poussée pendant la dernière seconde, en ˚T
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")
endstirling.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.
- number
- la vitesse que produit le moteur, 0, 16 ou 32 tr/min
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()
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.
- number
- le combustible qui reste dans la barre, en secondes
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()
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.
- boolean
- true tant que la barre brûle
local barre = peripheral.find("reactor_rod")
print(barre.active(), barre.temperature())Voir aussi heat_block.fuel()
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.
- number
- la chaleur que l'évent a prise aux barres pendant la dernière seconde, en ˚T
local evt = peripheral.find("reactor_heat_vent")
print(evt.extracting() .. " prises, évent à " .. evt.temperature())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é.
- number
- le nombre de barres que l'accepteur alimente
local accepteur = peripheral.find("reactor_fuel_acceptor")
print(accepteur.rods() .. " barres")Voir aussi reactor_fuel_acceptor.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.
- number
- le combustible moyen de ses barres, en secondes ; 0 sans barre
local accepteur = peripheral.find("reactor_fuel_acceptor")
print(math.floor(accepteur.fuel() / 60) .. " min de combustible")Voir aussi heat_block.fuel()
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.
- number
- la température de sa barre la plus chaude, en ˚T ; 0 sans barre
local accepteur = peripheral.find("reactor_fuel_acceptor")
if accepteur.temperature() > 20000 then
print("Trop chaud !")
endVoir 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.
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)
endaccepteur.count() et coffre.push viennent de Inventaires : l'accepteur ne prend que du combustible, le coffre ne devrait donc rien contenir d'autre.