Enchantment Industry
Le Blaze Enchanteur, le Blaze forgeron et l'Imprimante de Create: Enchantment Industry pilotés par un ordinateur : niveau d'enchantement, expérience liquide, mode de forge, résultats et copies.
Le Blaze Enchanteur, le Blaze forgeron et l'Imprimante sont des blocs de Create: Enchantment Industry (qui demande lui-même Create: Dragons Plus). Sans ce mod, ces blocs n'existent pas, et peripheral.find("blaze_enchanter") renvoie nil.
Create: Enchantment Industry fait de l'expérience un fluide et met des blazes au travail avec. Le Blaze Enchanteur (Blaze Enchanter, c'est son nom en jeu) enchante les objets qu'on lui donne, comme une table d'enchantement ; le Blaze forgeron (Blaze Forger) fusionne, applique et extrait des enchantements, comme une enclume ; l'Imprimante (Printer) copie un modèle (un livre enchanté, un livre écrit, un nom...) sur les objets qui passent sous elle. Un ordinateur relié à ces blocs règle le niveau d'enchantement et le mode de forge, surveille l'expérience des blazes, et lit chaque objet et chaque résultat : de quoi faire une chaîne d'enchantement qui rend compte de ce qu'elle produit, une jauge qui réclame de l'expérience avant la panne, ou une forge qui change de mode toute seule.
| Bloc (en jeu) | type de périphérique | ce qu'il lit ou règle |
|---|---|---|
| Blaze Enchanteur | blaze_enchanter | son expérience et sa chaleur, le niveau d'enchantement, son objet, ce qu'il peut donner, le coût |
| Blaze forgeron | blaze_forger | son expérience et sa chaleur, le mode de forge, ses entrées, ses sorties et son résultat |
| Imprimante | printer | son modèle, ce qu'elle imprime, le fluide que coûte une copie, son avancement |
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 blaze_enchanter@12,64,-30. peripheral.find("blaze_forger") prend le premier.
local enchanteur = peripheral.find("blaze_enchanter")
enchanteur.set_level(30)
print(enchanteur.experience() .. " mB d'expérience, chaleur " .. enchanteur.heat())Les deux blazes ont les mêmes mesures de leur expérience et de leur travail (la première section ci-dessous). L'enchanteur y ajoute les méthodes de son niveau d'enchantement, le forgeron celles de son mode de forge : set_mode n'existe que sur un forgeron, set_level que sur un enchanteur. Chaque méthode dit quel blaze l'a.
Chaque méthode relit le bloc quand on l'appelle. Quand le bloc a disparu, l'appel arrête le programme avec blaze enchanter removed, blaze forger removed ou printer removed ; quand son chunk n'est pas chargé, avec peripheral is not loaded. Une autre version du mod à laquelle il manque une pièce donne this version of Create: Enchantment Industry has no ..., et une erreur du mod lui-même Create: Enchantment Industry error: ....
Aussi des réservoirs. Un blaze garde son expérience dans deux réservoirs, que tank.tanks() (voir Réservoirs) lit aussi, mais seulement par-dessous : l'ordinateur ou le Câble de données doit toucher le dessous du blaze, la face qu'utilise son tuyau. tanks() donne alors l'expérience liquide, puis la super expérience. Un tuyau occupe en général cette place : experience() et super_experience() lisent la même chose depuis n'importe quelle face. Le réservoir de l'Imprimante se voit de toutes les faces sauf le dessous.
Les autres blocs. Les autres blocs du mod, comme le Classic Blaze Enchanter, l'Égout de meule ou la Lanterne d'expérience, n'ont pas de méthodes à eux : tout au plus les méthodes génériques d'un bloc qui contient des fluides ou qui tourne. Les blocs qu'il ajoute avec Apotheosis ou Apothic Enchanting (Blaze Composer, Affix Augmentor, Gem Cutter, Infuser, Brass Bookshelf...) n'ont pas non plus de périphérique à eux.
blaze.heat() | La chaleur du blaze, d'après ce que contiennent ses réservoirs : "smouldering" sans expérience, "fading" sous 1,25 % de son réservoir (50 mB sur 4000), "kindled" au-dessus, et "seething" dès qu'il contient de la super expérience : c'est le mode super. Les deux blazes l'ont. |
blaze.creative() | true dès qu'un Cake pour Blaze créatif a nourri le blaze : son réservoir devient créatif et reste plein, et experience() (ou super_experience()) lit toute sa capacité. Les deux blazes l'ont. |
blaze.experience() | L'expérience liquide du réservoir du blaze, en mB : le réservoir que remplissent son tuyau et les objets d'expérience ordinaires. Hors mode super, c'est lui qui paie un travail. Les deux blazes l'ont. |
blaze.super_experience() | La super expérience du blaze, en mB. Plus de 0 veut dire mode super, où chaque travail ne se paie qu'avec ce réservoir. Les deux blazes l'ont. |
blaze.experience_capacity() | Ce que contient au plus chaque réservoir du blaze, en mB : 4000 par défaut (configurations serveur blazeEnchanterFluidCapacity et blazeForgerFluidCapacity). Le réservoir de super expérience a la même taille. Les deux blazes l'ont. |
blaze.cursed() | true tant que le blaze est en mode super sans ciel dégagé au-dessus de lui : aucun éclair ne peut venir, donc pas besoin de Paratonnerre, mais le prochain résultat est gâché (une malédiction peut accompagner un enchantement, un objet forgé coûte plus cher à réparer). false hors mode super. Les deux blazes l'ont. |
blaze.running() | true pendant les 10 secondes d'un travail ; false quand le blaze attend un objet, de l'expérience, ou qu'on prenne son résultat. Les deux blazes l'ont. |
blaze.progress() | L'avancement du travail en cours, de 0 à 1 ; 0 quand rien ne tourne. Les deux blazes l'ont. |
blaze.problem() | Pourquoi le blaze ne travaille pas, en un mot : |
enchanteur.level() | Le niveau réglé sur l'enchanteur, de 0 (non réglé : il n'enchante pas) à max_level(). Blaze Enchanteur seulement. |
enchanteur.max_level() | Le niveau le plus haut qu'accepte l'enchanteur en ce moment : 30 par défaut, 60 en mode super (configurations serveur blazeEnchanterMaxEnchantLevel et blazeEnchanterMaxSuperEnchantLevel). Il change dès que la super expérience arrive ou s'épuise. Blaze Enchanteur seulement. |
enchanteur.set_level(level) | Règle le panneau, comme un joueur, à la fin du tick, et renvoie le niveau retenu : entre 0 et max_level(). 0 arrête l'enchantement. Le nombre doit être entier : set_level(12.5) arrête le programme avec bad argument #1 to 'set_level' (number has no integer representation). Blaze Enchanteur seulement. |
enchanteur.item() | L'objet posé sur l'enchanteur, avant ou après son enchantement. Blaze Enchanteur seulement. La table a les champs de tous les objets de cette page (le modèle, les entrées et sorties du forgeron, le modèle de l'Imprimante) : |
enchanteur.template() | L'objet posé sur l'emplacement de sa face avant, qui met l'enchanteur en mode modèle (voir plus haut), sous forme de table d'objet comme blaze.item(). nil sans modèle : l'enchanteur enchante alors l'objet lui-même. Seul un joueur le pose. Blaze Enchanteur seulement. |
enchanteur.enchantments() | Ce que l'objet tenu peut recevoir à ce niveau et à cette chaleur (en mode modèle, ce que le modèle peut recevoir) : la liste que montrent les Lunettes d'ingénieur. Le résultat en tire quelques-uns. En mode super sous un ciel couvert, les malédictions qui peuvent s'ajouter sont aussi dans la liste, avec curse = true. Vide quand l'enchanteur ne tient rien. Blaze Enchanteur seulement. |
enchanteur.cost() | Ce que coûte l'enchantement de l'objet tenu à ce niveau et à cette chaleur, en mB (points d'expérience) : le coût que montrent les Lunettes d'ingénieur. En mode super, il se paie en super expérience. nil quand l'enchanteur ne tient rien ou que le travail ne coûte rien (niveau 0). Blaze Enchanteur seulement. |
enchanteur.done() | true de la fin d'un travail jusqu'à ce qu'un joueur ou un bras prenne l'objet, que item() montre alors avec ses enchantements. Pour compter les résultats, attendez done(), puis qu'il repasse à false. Blaze Enchanteur seulement. |
forgeron.mode() | Le mode de forge du panneau. Un forgeron neuf commence en "merge". Blaze forgeron seulement. |
forgeron.set_mode(mode) | Règle le panneau, comme un joueur, à la fin du tick. Un travail en cours s'arrête, et le résultat est recalculé pour le nouveau mode. Les majuscules sont acceptées ; un autre mot arrête le programme avec bad argument #1 to 'set_mode' (merge, apply, extract). Ne renvoie rien. Blaze forgeron seulement. |
forgeron.inputs() | Ce qui se trouve dans ses deux entrées : first l'objet travaillé, second ce qu'on lui ajoute (voir le tableau plus haut). Chacun est une table d'objet comme blaze.item(), ou nil quand cette entrée est vide. Les deux se vident à la fin d'un travail. Blaze forgeron seulement. |
forgeron.outputs() | Les résultats qui attendent dans ses deux sorties : first le résultat principal, second le modèle rempli d'une extraction. Chacun est une table d'objet, ou nil. Tant que l'une contient quelque chose, le forgeron ne prend aucun nouvel objet. Blaze forgeron seulement. |
forgeron.result() | Ce que le forgeron a calculé pour ses entrées et son mode, avant le travail : first et second les objets qu'il mettra dans ses sorties (tables d'objet, ou nil), cost l'expérience que cela coûte en mB, levels ce coût en niveaux, comme celui d'une enclume. nil quand une entrée manque ou que les deux ne donnent rien : blaze.problem() dit lequel. Blaze forgeron seulement. |
imprimante.template() | Le modèle de l'Imprimante, sous forme de table d'objet comme blaze.item() : un livre enchanté montre ses enchantments. nil sans modèle. Seul un joueur le pose. |
imprimante.mode() | La ligne du tableau ci-dessus que donne son modèle : "enchanted_book", "written_book", "custom_name", "copy", "package_address", "package_pattern" ou "banner_pattern" ; "other" pour une sorte qu'ajoute un addon. Pour tout autre modèle, "recipe" : l'Imprimante suit alors les recettes d'impression de packs de données ou d'autres mods (Enchantment Industry n'en fournit aucune). Elle vaut aussi "recipe" sans modèle, quand l'Imprimante n'imprime rien : testez template() pour faire la différence. |
imprimante.cost() | Combien de fluide prend une copie, avec le fluide que contient son réservoir en ce moment, en mB (voir le tableau plus haut ; pour un livre enchanté, autant de mB d'expérience liquide que ses enchantements valent de points). nil quand le réservoir est vide ou que son fluide n'imprime pas ce modèle, et en mode "recipe", où chaque recette a son propre coût. |
imprimante.running() | true du début d'une impression jusqu'à la sortie de la copie ; false sinon, même quand un objet attend du fluide sous elle. |
imprimante.progress() | L'avancement de l'impression en cours, de 0 à 1 : 1 quand la copie sort, 0 quand rien ne s'imprime. |
Expérience liquide et chaleur
Les deux blazes brûlent de l'expérience liquide : 1 mB vaut 1 point d'expérience, donc le réservoir de 4000 mB d'un blaze (par défaut, configurations serveur blazeEnchanterFluidCapacity et blazeForgerFluidCapacity) contient 4000 points. Elle arrive par un tuyau sous le blaze (par le dessous seulement), ou par des objets donnés à la main ou par un Bras mécanique : un Seau d'enchantement (1000 mB), la Pépite d'expérience (3) et le Bloc d'expérience (27) de Create. Ce qu'il en reste fixe sa chaleur, blaze.heat().
La super expérience. Un second réservoir de la même taille contient la super expérience. Elle ne vient que d'objets, jamais par tuyau : Pépite de Super Expérience (3), Bloc de super expérience (27), Tranche de cake d'enchantement (250), Cake d'enchantement (1000). Tant qu'un blaze en contient, il est en surchauffe et travaille en mode super, en ne payant qu'avec sa super expérience :
- l'enchanteur monte jusqu'au niveau 60 au lieu de 30 (configurations serveur
blazeEnchanterMaxSuperEnchantLeveletblazeEnchanterMaxEnchantLevel), peut donner des enchantements de trésor comme Raccommodage, et met les enchantements un niveau au-dessus de leur maximum habituel (sauf Raccommodage et Infinité) ; - le forgeron monte lui aussi les niveaux un cran au-dessus de leur maximum, et peut extraire des malédictions ;
- tous deux ignorent les incompatibilités entre enchantements (configuration serveur
ignoreEnchantmentCompatibility).
La foudre du mode super. Un travail en mode super se termine en appelant la foudre sur le blaze. Il faut pour cela un ciel dégagé : aucun bloc au-dessus du blaze (le verre compte), dans une dimension qui a un ciel.
- Sous un ciel dégagé, l'éclair va sur un Paratonnerre à moins de 128 blocs qui est le bloc le plus haut de sa colonne, et le travail s'achève.
- Sous un ciel couvert (ou dans le Nether, l'End), pas d'éclair, mais le résultat est gâché : l'enchanteur peut y ajouter une malédiction (un tirage, 1 chance sur 2 par défaut), le forgeron augmente son coût de réparation comme le ferait un passage de plus à l'enclume.
blaze.cursed()dit quand.
Sous un ciel dégagé sans Paratonnerre à portée, l'éclair frappe le blaze lui-même : le bloc est détruit, et il ne reste à sa place qu'un Brûleur à Blaze allumé, sans son blaze.
Un travail dure 10 secondes (200 ticks). Le blaze ne commence que s'il contient assez d'expérience pour le coût, paie à la fin, et recommence de zéro s'il en manque entre-temps.
blaze.heat()
La chaleur du blaze, d'après ce que contiennent ses réservoirs : "smouldering" sans expérience, "fading" sous 1,25 % de son réservoir (50 mB sur 4000), "kindled" au-dessus, et "seething" dès qu'il contient de la super expérience : c'est le mode super. Les deux blazes l'ont.
- string
- "smouldering", "fading", "kindled" ou "seething"
local blaze = peripheral.find("blaze_enchanter")
if blaze.heat() == "seething" then
print("mode super, jusqu'au niveau " .. blaze.max_level())
endVoir aussi blaze.experience() blaze.super_experience()
blaze.creative()
true dès qu'un Cake pour Blaze créatif a nourri le blaze : son réservoir devient créatif et reste plein, et experience() (ou super_experience()) lit toute sa capacité. Les deux blazes l'ont.
- boolean
- vrai quand le blaze a mangé un Cake pour Blaze créatif
blaze.experience()
L'expérience liquide du réservoir du blaze, en mB : le réservoir que remplissent son tuyau et les objets d'expérience ordinaires. Hors mode super, c'est lui qui paie un travail. Les deux blazes l'ont.
- number
- l'expérience liquide de son réservoir, en mB (1 mB vaut 1 point)
Une jauge d'expérience qui en réclame avant que le réservoir ne soit à sec :
local blaze = peripheral.find("blaze_forger")
local part = blaze.experience() / blaze.experience_capacity()
print(math.floor(part * 100) .. " % d'expérience")
if part < 0.1 then
print("nourrissez le forgeron")
endVoir aussi blaze.experience_capacity() blaze.super_experience()
blaze.super_experience()
La super expérience du blaze, en mB. Plus de 0 veut dire mode super, où chaque travail ne se paie qu'avec ce réservoir. Les deux blazes l'ont.
- number
- la super expérience de son second réservoir, en mB
if blaze.super_experience() > 0 then
print(blaze.super_experience() .. " mB de super expérience")
endVoir aussi blaze.heat() blaze.cursed()
blaze.experience_capacity()
Ce que contient au plus chaque réservoir du blaze, en mB : 4000 par défaut (configurations serveur blazeEnchanterFluidCapacity et blazeForgerFluidCapacity). Le réservoir de super expérience a la même taille. Les deux blazes l'ont.
- number
- la taille de chacun de ses deux réservoirs, en mB
blaze.cursed()
true tant que le blaze est en mode super sans ciel dégagé au-dessus de lui : aucun éclair ne peut venir, donc pas besoin de Paratonnerre, mais le prochain résultat est gâché (une malédiction peut accompagner un enchantement, un objet forgé coûte plus cher à réparer). false hors mode super. Les deux blazes l'ont.
- boolean
- vrai en mode super sous un ciel couvert
if blaze.cursed() then
print("mode super sous un toit : dégagez le ciel")
endVoir aussi blaze.super_experience()
blaze.running()
true pendant les 10 secondes d'un travail ; false quand le blaze attend un objet, de l'expérience, ou qu'on prenne son résultat. Les deux blazes l'ont.
- boolean
- vrai pendant un travail
Voir aussi blaze.progress() blaze.problem()
blaze.progress()
L'avancement du travail en cours, de 0 à 1 ; 0 quand rien ne tourne. Les deux blazes l'ont.
- number
- l'avancement du travail, de 0 à 1
local fait = math.floor(blaze.progress() * 20)
print("[" .. string.rep("#", fait) .. string.rep(".", 20 - fait) .. "]")Voir aussi blaze.running()
blaze.problem()
Pourquoi le blaze ne travaille pas, en un mot :
- string|nil
- pourquoi le blaze attend ; nil quand rien ne l'arrête
| valeur | blaze | sens |
|---|---|---|
"level_not_set" | enchanteur | il tient un objet, mais son niveau est à 0 |
"invalid_item" | enchanteur | son objet ne peut pas être enchanté à ce niveau et à cette chaleur (un Modèle de super enchantement hors mode super...) |
"incomplete_input" | forgeron | une de ses deux entrées est vide |
"invalid" | forgeron | ses deux entrées ne donnent rien dans ce mode (les Lunettes d'ingénieur disent pourquoi) |
"output_blocked" | forgeron | un résultat attend dans ses sorties |
"not_enough_experience" | les deux | le travail coûte plus que ce qu'il contient (plus que sa super expérience, en mode super) |
nil quand rien ne l'arrête, et aussi quand il n'y a rien à faire : un blaze vide, ou un enchanteur dont l'objet est terminé. Les deux blazes l'ont.
local p = blaze.problem()
rs.set("top", p == "not_enough_experience") -- une lampe réclame de l'expérienceVoir aussi blaze.running()
Blaze Enchanteur
Le Blaze Enchanteur prend un objet à la fois, donné à la main ou par un Bras mécanique, et l'enchante au niveau de son panneau de réglage (Niveau d'enchantement). Ce niveau est celui d'une table d'enchantement : il décide quels enchantements peuvent venir et avec quelle force, de 1 à 30 (60 en mode super). Le résultat est tiré au hasard parmi eux, comme à une table. Le coût grandit avec le niveau : 27 mB au niveau 10, 321 mB au niveau 30, 2157 mB au niveau 60 avec les réglages par défaut (blaze.cost() le donne exactement). Au niveau 0, il ne fait rien. L'objet enchanté attend sur le blaze qu'un joueur ou un bras le prenne (blaze.done()).
Le mode modèle. Un objet enchantable cliqué sur l'emplacement de sa face avant devient son modèle (blaze.template()) : le blaze n'enchante alors plus d'objets, mais écrit des enchantements que ce modèle pourrait recevoir dans des Modèles d'enchantement vierges (des Modèles de super enchantement en mode super), qu'un forgeron applique ensuite. Une main vide sur l'emplacement retire le modèle.
enchanteur.level()
Le niveau réglé sur l'enchanteur, de 0 (non réglé : il n'enchante pas) à max_level(). Blaze Enchanteur seulement.
- number
- le niveau d'enchantement de son panneau, 0 s'il n'est pas réglé
local enchanteur = peripheral.find("blaze_enchanter")
print("niveau " .. enchanteur.level() .. " sur " .. enchanteur.max_level())Voir aussi blaze.set_level() blaze.max_level()
enchanteur.max_level()
Le niveau le plus haut qu'accepte l'enchanteur en ce moment : 30 par défaut, 60 en mode super (configurations serveur blazeEnchanterMaxEnchantLevel et blazeEnchanterMaxSuperEnchantLevel). Il change dès que la super expérience arrive ou s'épuise. Blaze Enchanteur seulement.
- number
- le niveau le plus haut qu'il accepte en ce moment, 30 ou 60 par défaut
Voir aussi blaze.set_level()
enchanteur.set_level(level)
Règle le panneau, comme un joueur, à la fin du tick, et renvoie le niveau retenu : entre 0 et max_level(). 0 arrête l'enchantement. Le nombre doit être entier : set_level(12.5) arrête le programme avec bad argument #1 to 'set_level' (number has no integer representation). Blaze Enchanteur seulement.
levelnumber- le nouveau niveau, un nombre entier
- number
- le niveau retenu, entre 0 et max_level()
local enchanteur = peripheral.find("blaze_enchanter")
print(enchanteur.set_level(99))Hors mode super, cela affiche 30 : demandez trop pour obtenir le niveau le plus haut.
Voir aussi blaze.level() blaze.cost()
enchanteur.item()
L'objet posé sur l'enchanteur, avant ou après son enchantement. Blaze Enchanteur seulement. La table a les champs de tous les objets de cette page (le modèle, les entrées et sorties du forgeron, le modèle de l'Imprimante) :
- table|nil
- l'objet qu'il tient, {name =, count =, display =, enchantments =} ; nil s'il est vide
| champ | contenu |
|---|---|
name | l'identifiant de l'objet, comme "minecraft:book" |
count | combien (1 sur un blaze) |
display | le nom que voit un joueur |
enchantments | ses enchantements (ceux d'un livre ou d'un modèle aussi), une liste de {name =, level =, curse =} ; absent s'il n'en a pas |
Dans enchantments, name est l'identifiant de l'enchantement ("minecraft:sharpness"), level son niveau, et curse vaut true pour une malédiction.
local o = enchanteur.item()
if o and o.enchantments then
for _, en in ipairs(o.enchantments) do
print(en.name .. " " .. en.level)
end
endVoir aussi blaze.done() blaze.enchantments()
enchanteur.template()
L'objet posé sur l'emplacement de sa face avant, qui met l'enchanteur en mode modèle (voir plus haut), sous forme de table d'objet comme blaze.item(). nil sans modèle : l'enchanteur enchante alors l'objet lui-même. Seul un joueur le pose. Blaze Enchanteur seulement.
- table|nil
- son modèle, une table d'objet ; nil sans modèle
Ce que l'objet tenu peut recevoir à ce niveau et à cette chaleur (en mode modèle, ce que le modèle peut recevoir) : la liste que montrent les Lunettes d'ingénieur. Le résultat en tire quelques-uns. En mode super sous un ciel couvert, les malédictions qui peuvent s'ajouter sont aussi dans la liste, avec curse = true. Vide quand l'enchanteur ne tient rien. Blaze Enchanteur seulement.
- table
- les enchantements qu'il peut donner, une liste de {name =, level =, curse =}
for _, en in ipairs(enchanteur.enchantments()) do
print(en.name .. " " .. en.level)
endVoir aussi blaze.item()
enchanteur.cost()
Ce que coûte l'enchantement de l'objet tenu à ce niveau et à cette chaleur, en mB (points d'expérience) : le coût que montrent les Lunettes d'ingénieur. En mode super, il se paie en super expérience. nil quand l'enchanteur ne tient rien ou que le travail ne coûte rien (niveau 0). Blaze Enchanteur seulement.
- number|nil
- l'expérience que coûtera le travail, en mB ; nil sans objet
local besoin = enchanteur.cost()
if besoin and besoin > enchanteur.experience() then
print("il manque " .. (besoin - enchanteur.experience()) .. " mB")
endVoir aussi blaze.set_level() blaze.experience()
enchanteur.done()
true de la fin d'un travail jusqu'à ce qu'un joueur ou un bras prenne l'objet, que item() montre alors avec ses enchantements. Pour compter les résultats, attendez done(), puis qu'il repasse à false. Blaze Enchanteur seulement.
- boolean
- vrai quand l'objet enchanté attend d'être pris
Voir aussi blaze.item()
Blaze forgeron
Le Blaze forgeron fait le travail d'une enclume avec de l'expérience. Il a deux entrées et deux sorties : les objets arrivent à la main ou par un Bras mécanique, et les résultats attendent dans les sorties qu'on les prenne. Tant qu'un résultat attend, le forgeron ne prend rien de nouveau (problem() donne "output_blocked"). Son panneau de réglage (Forging Mode) choisit ce qu'il fait :
| mode | première entrée | seconde entrée | résultat |
|---|---|---|---|
"merge" | un objet | le même objet ; ou deux livres enchantés ; ou deux modèles remplis d'une même sorte | le premier, avec les enchantements des deux (et réparé, pour un outil usé) |
"apply" | l'objet à enchanter, ou un Livre | un livre enchanté ou un Modèle d'enchantement rempli | l'objet avec ces enchantements (un modèle sur un Livre donne un livre enchanté) |
"extract" | un objet, livre ou modèle enchanté | un Modèle d'enchantement vierge | la source privée d'un enchantement, et le modèle qui le contient |
Comme à l'enclume, un niveau ne monte que quand deux niveaux égaux se rencontrent (Tranchant III et III donnent IV), et jamais au-dessus du maximum de l'enchantement hors mode super. Le coût se compte en niveaux, comme celui d'une enclume, et le forgeron paie les points d'expérience de ces niveaux comptés depuis 0 : 55 mB pour 5 niveaux, 160 mB pour 10. Les modèles doivent aller avec la chaleur : les Modèles de super enchantement seulement en mode super, les ordinaires seulement hors de lui.
forgeron.mode()
Le mode de forge du panneau. Un forgeron neuf commence en "merge". Blaze forgeron seulement.
- string
- "merge", "apply" ou "extract"
local forgeron = peripheral.find("blaze_forger")
print(forgeron.mode())Voir aussi blaze.set_mode()
forgeron.set_mode(mode)
Règle le panneau, comme un joueur, à la fin du tick. Un travail en cours s'arrête, et le résultat est recalculé pour le nouveau mode. Les majuscules sont acceptées ; un autre mot arrête le programme avec bad argument #1 to 'set_mode' (merge, apply, extract). Ne renvoie rien. Blaze forgeron seulement.
modestring- "merge", "apply" ou "extract"
forgeron.set_mode("extract")
sleep(0) -- le mode change à la fin du tick
print(forgeron.mode())Voir aussi blaze.mode() blaze.result()
forgeron.inputs()
Ce qui se trouve dans ses deux entrées : first l'objet travaillé, second ce qu'on lui ajoute (voir le tableau plus haut). Chacun est une table d'objet comme blaze.item(), ou nil quand cette entrée est vide. Les deux se vident à la fin d'un travail. Blaze forgeron seulement.
- table
- {first =, second =}, les objets de ses deux entrées
local e = forgeron.inputs()
print(e.first and e.first.display or "vide", e.second and e.second.display or "vide")Voir aussi blaze.outputs() blaze.result()
forgeron.outputs()
Les résultats qui attendent dans ses deux sorties : first le résultat principal, second le modèle rempli d'une extraction. Chacun est une table d'objet, ou nil. Tant que l'une contient quelque chose, le forgeron ne prend aucun nouvel objet. Blaze forgeron seulement.
- table
- {first =, second =}, les résultats qui attendent d'être pris
Voir aussi blaze.inputs()
forgeron.result()
Ce que le forgeron a calculé pour ses entrées et son mode, avant le travail : first et second les objets qu'il mettra dans ses sorties (tables d'objet, ou nil), cost l'expérience que cela coûte en mB, levels ce coût en niveaux, comme celui d'une enclume. nil quand une entrée manque ou que les deux ne donnent rien : blaze.problem() dit lequel. Blaze forgeron seulement.
- table|nil
- {first =, second =, cost =, levels =}, ce que donneront ses entrées ; nil si elles ne donnent rien
local r = forgeron.result()
if r then
print(r.first.display .. " : " .. r.levels .. " niveaux, " .. r.cost .. " mB")
endVoir aussi blaze.problem() blaze.set_mode()
Imprimante
L'Imprimante se place au-dessus d'un tapis roulant ou d'un dépôt, comme un Bec verseur, et imprime sur les objets qu'ils amènent sous elle, en payant avec le fluide de son réservoir (4000 mB par défaut, configuration serveur printerFluidCapacity, rempli par tuyau depuis toutes les faces sauf le dessous). Ce qu'elle imprime vient de son modèle : une copie de l'objet qu'un joueur clique sur l'emplacement de sa face avant. Une impression dure 2,5 secondes (50 ticks). Un objet auquel le modèle ne s'applique pas passe son chemin, comme avec un fluide qui n'imprime pas ; un objet qu'elle peut imprimer attend sous elle que le réservoir en contienne assez.
| mode | modèle | imprime sur | fluide par copie |
|---|---|---|---|
"enchanted_book" | un Livre enchanté | des Livres | de l'expérience liquide, selon ses enchantements |
"written_book" | un Livre écrit | des Livres | de la teinture noire, 10 mB par page |
"custom_name" | une Étiquette qui porte un nom | n'importe quel objet | une teinture, 250 mB (le nom prend sa couleur), ou de l'expérience liquide, 10 mB |
"copy" | un objet de Create qui se copie (un Presse-papiers...), ou un Schéma | le même objet (des Schémas vides pour un Schéma) | de la teinture noire, 10 mB |
"package_address" | un Colis qui porte une adresse | des colis | de la teinture noire, 10 mB |
"package_pattern" | un Colis sans adresse | d'autres colis, qui prennent son aspect | de la teinture noire, 100 mB |
"banner_pattern" | une bannière à un seul motif | des bannières | une teinture, 100 mB (le motif prend sa couleur) |
Les teintures sont les teintures liquides de Create: Dragons Plus.
imprimante.template()
Le modèle de l'Imprimante, sous forme de table d'objet comme blaze.item() : un livre enchanté montre ses enchantments. nil sans modèle. Seul un joueur le pose.
- table|nil
- son modèle, {name =, count =, display =, enchantments =} ; nil sans modèle
local imprimante = peripheral.find("printer")
local m = imprimante.template()
if m then
print("imprime " .. m.display)
endVoir aussi printer.mode()
imprimante.mode()
La ligne du tableau ci-dessus que donne son modèle : "enchanted_book", "written_book", "custom_name", "copy", "package_address", "package_pattern" ou "banner_pattern" ; "other" pour une sorte qu'ajoute un addon. Pour tout autre modèle, "recipe" : l'Imprimante suit alors les recettes d'impression de packs de données ou d'autres mods (Enchantment Industry n'en fournit aucune). Elle vaut aussi "recipe" sans modèle, quand l'Imprimante n'imprime rien : testez template() pour faire la différence.
- string
- ce qu'elle imprime d'après son modèle, ou "recipe"
if imprimante.template() == nil then
print("pas de modèle")
else
print("mode " .. imprimante.mode())
endVoir aussi printer.template() printer.cost()
imprimante.cost()
Combien de fluide prend une copie, avec le fluide que contient son réservoir en ce moment, en mB (voir le tableau plus haut ; pour un livre enchanté, autant de mB d'expérience liquide que ses enchantements valent de points). nil quand le réservoir est vide ou que son fluide n'imprime pas ce modèle, et en mode "recipe", où chaque recette a son propre coût.
- number|nil
- le fluide que prend une copie avec ce que contient son réservoir, en mB ; nil si ce fluide n'imprime pas
Avec tank.tanks() (l'ordinateur à côté de l'Imprimante ou au-dessus), les copies qui restent :
local imprimante = peripheral.find("printer")
local chacune = imprimante.cost()
if chacune then
print(math.floor(imprimante.tanks()[1].amount / chacune) .. " copies restantes")
else
print("ce fluide ne l'imprime pas")
endVoir aussi printer.mode() tank.tanks()
imprimante.running()
true du début d'une impression jusqu'à la sortie de la copie ; false sinon, même quand un objet attend du fluide sous elle.
- boolean
- vrai pendant qu'elle imprime
Voir aussi printer.progress()
imprimante.progress()
L'avancement de l'impression en cours, de 0 à 1 : 1 quand la copie sort, 0 quand rien ne s'imprime.
- number
- l'avancement de la copie, de 0 à 1
print(math.floor(imprimante.progress() * 100) .. " %")Voir aussi printer.running()
Un poste d'enchantement
Un petit programme complet : un Blaze Enchanteur à gauche de l'ordinateur, alimenté en livres par un Bras mécanique qui les reprend aussi, et une lampe posée sur l'ordinateur. L'ordinateur garde le niveau à 30 (ou au plus haut s'il est plus bas), affiche chaque livre produit avec ses enchantements, dit pourquoi le blaze attend, et allume la lampe quand l'expérience manque. Il regarde dix fois par seconde, pour voir chaque résultat avant que le bras ne le prenne.
local enchanteur = peripheral.wrap("left")
local NIVEAU = 30
local produits = 0
local affiche = nil
local function noms(objet)
local liste = {}
for _, en in ipairs(objet.enchantments or {}) do
local texte = en.name .. " " .. en.level
if en.curse then
texte = texte .. " (malédiction)"
end
table.insert(liste, texte)
end
return table.concat(liste, ", ")
end
while true do
if enchanteur.level() ~= math.min(NIVEAU, enchanteur.max_level()) then
enchanteur.set_level(NIVEAU)
end
if enchanteur.done() then
local objet = enchanteur.item()
if objet then
produits = produits + 1
print(produits .. ". " .. objet.display .. " : " .. noms(objet))
end
while enchanteur.done() do -- jusqu'à ce que le bras le prenne
sleep(0.1)
end
end
local probleme = enchanteur.problem()
if probleme ~= affiche then
if probleme then
print("en attente : " .. probleme)
end
affiche = probleme
end
rs.set("top", probleme == "not_enough_experience")
sleep(0.1)
endEn mode super, le niveau reste à 30 tant que NIVEAU ne demande pas plus : mettez-le à 60 pour profiter de toute la plage.