Create: Computing AgesDoc Brass
Périphériques

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.

Il faut Create: Enchantment Industry

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ériquece qu'il lit ou règle
Blaze Enchanteurblaze_enchanterson expérience et sa chaleur, le niveau d'enchantement, son objet, ce qu'il peut donner, le coût
Blaze forgeronblaze_forgerson expérience et sa chaleur, le mode de forge, ses entrées, ses sorties et son résultat
Imprimanteprinterson 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.

Brass
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.

Méthodes
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 blazeEnchanterMaxSuperEnchantLevel et blazeEnchanterMaxEnchantLevel), 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.
Un travail en mode super demande un Paratonnerre

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()

→ string

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.

Renvoie
string
"smouldering", "fading", "kindled" ou "seething"
Brass
local blaze = peripheral.find("blaze_enchanter")
if blaze.heat() == "seething" then
  print("mode super, jusqu'au niveau " .. blaze.max_level())
end

Voir aussi blaze.experience() blaze.super_experience()

#

blaze.creative()

→ boolean

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.

Renvoie
boolean
vrai quand le blaze a mangé un Cake pour Blaze créatif
#

blaze.experience()

→ number

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.

Renvoie
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 :

Brass
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")
end

Voir aussi blaze.experience_capacity() blaze.super_experience()

#

blaze.super_experience()

→ number

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.

Renvoie
number
la super expérience de son second réservoir, en mB
Brass
if blaze.super_experience() > 0 then
  print(blaze.super_experience() .. " mB de super expérience")
end

Voir aussi blaze.heat() blaze.cursed()

#

blaze.experience_capacity()

→ number

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.

Renvoie
number
la taille de chacun de ses deux réservoirs, en mB
#

blaze.cursed()

→ boolean

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.

Renvoie
boolean
vrai en mode super sous un ciel couvert
Brass
if blaze.cursed() then
  print("mode super sous un toit : dégagez le ciel")
end

Voir aussi blaze.super_experience()

#

blaze.running()

→ boolean

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.

Renvoie
boolean
vrai pendant un travail

Voir aussi blaze.progress() blaze.problem()

#

blaze.progress()

→ number

L'avancement du travail en cours, de 0 à 1 ; 0 quand rien ne tourne. Les deux blazes l'ont.

Renvoie
number
l'avancement du travail, de 0 à 1
Brass
local fait = math.floor(blaze.progress() * 20)
print("[" .. string.rep("#", fait) .. string.rep(".", 20 - fait) .. "]")

Voir aussi blaze.running()

#

blaze.problem()

→ string|nil

Pourquoi le blaze ne travaille pas, en un mot :

Renvoie
string|nil
pourquoi le blaze attend ; nil quand rien ne l'arrête
valeurblazesens
"level_not_set"enchanteuril tient un objet, mais son niveau est à 0
"invalid_item"enchanteurson objet ne peut pas être enchanté à ce niveau et à cette chaleur (un Modèle de super enchantement hors mode super...)
"incomplete_input"forgeronune de ses deux entrées est vide
"invalid"forgeronses deux entrées ne donnent rien dans ce mode (les Lunettes d'ingénieur disent pourquoi)
"output_blocked"forgeronun résultat attend dans ses sorties
"not_enough_experience"les deuxle 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.

Brass
local p = blaze.problem()
rs.set("top", p == "not_enough_experience") -- une lampe réclame de l'expérience

Voir 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()

→ number

Le niveau réglé sur l'enchanteur, de 0 (non réglé : il n'enchante pas) à max_level(). Blaze Enchanteur seulement.

Renvoie
number
le niveau d'enchantement de son panneau, 0 s'il n'est pas réglé
Brass
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()

→ number

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.

Renvoie
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)

→ number

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.

Paramètres
level number
le nouveau niveau, un nombre entier
Renvoie
number
le niveau retenu, entre 0 et max_level()
Brass
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()

→ table|nil

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) :

Renvoie
table|nil
l'objet qu'il tient, {name =, count =, display =, enchantments =} ; nil s'il est vide
champcontenu
namel'identifiant de l'objet, comme "minecraft:book"
countcombien (1 sur un blaze)
displayle nom que voit un joueur
enchantmentsses 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.

Brass
local o = enchanteur.item()
if o and o.enchantments then
  for _, en in ipairs(o.enchantments) do
    print(en.name .. " " .. en.level)
  end
end

Voir aussi blaze.done() blaze.enchantments()

#

enchanteur.template()

→ table|nil

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.

Renvoie
table|nil
son modèle, une table d'objet ; nil sans modèle
#

enchanteur.enchantments()

→ table⚙ coût 16

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.

Renvoie
table
les enchantements qu'il peut donner, une liste de {name =, level =, curse =}
Brass
for _, en in ipairs(enchanteur.enchantments()) do
  print(en.name .. " " .. en.level)
end

Voir aussi blaze.item()

#

enchanteur.cost()

→ number|nil

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.

Renvoie
number|nil
l'expérience que coûtera le travail, en mB ; nil sans objet
Brass
local besoin = enchanteur.cost()
if besoin and besoin > enchanteur.experience() then
  print("il manque " .. (besoin - enchanteur.experience()) .. " mB")
end

Voir aussi blaze.set_level() blaze.experience()

#

enchanteur.done()

→ boolean

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.

Renvoie
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 :

modepremière entréeseconde entréerésultat
"merge"un objetle même objet ; ou deux livres enchantés ; ou deux modèles remplis d'une même sortele premier, avec les enchantements des deux (et réparé, pour un outil usé)
"apply"l'objet à enchanter, ou un Livreun livre enchanté ou un Modèle d'enchantement remplil'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 viergela 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()

→ string

Le mode de forge du panneau. Un forgeron neuf commence en "merge". Blaze forgeron seulement.

Renvoie
string
"merge", "apply" ou "extract"
Brass
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.

Paramètres
mode string
"merge", "apply" ou "extract"
Brass
forgeron.set_mode("extract")
sleep(0) -- le mode change à la fin du tick
print(forgeron.mode())

Voir aussi blaze.mode() blaze.result()

#

forgeron.inputs()

→ table

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.

Renvoie
table
{first =, second =}, les objets de ses deux entrées
Brass
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()

→ table

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.

Renvoie
table
{first =, second =}, les résultats qui attendent d'être pris

Voir aussi blaze.inputs()

#

forgeron.result()

→ table|nil

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.

Renvoie
table|nil
{first =, second =, cost =, levels =}, ce que donneront ses entrées ; nil si elles ne donnent rien
Brass
local r = forgeron.result()
if r then
  print(r.first.display .. " : " .. r.levels .. " niveaux, " .. r.cost .. " mB")
end

Voir 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.

modemodèleimprime surfluide par copie
"enchanted_book"un Livre enchantédes Livresde l'expérience liquide, selon ses enchantements
"written_book"un Livre écritdes Livresde la teinture noire, 10 mB par page
"custom_name"une Étiquette qui porte un nomn'importe quel objetune 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émale même objet (des Schémas vides pour un Schéma)de la teinture noire, 10 mB
"package_address"un Colis qui porte une adressedes colisde la teinture noire, 10 mB
"package_pattern"un Colis sans adressed'autres colis, qui prennent son aspectde la teinture noire, 100 mB
"banner_pattern"une bannière à un seul motifdes bannièresune teinture, 100 mB (le motif prend sa couleur)

Les teintures sont les teintures liquides de Create: Dragons Plus.

#

imprimante.template()

→ table|nil

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.

Renvoie
table|nil
son modèle, {name =, count =, display =, enchantments =} ; nil sans modèle
Brass
local imprimante = peripheral.find("printer")
local m = imprimante.template()
if m then
  print("imprime " .. m.display)
end

Voir aussi printer.mode()

#

imprimante.mode()

→ string

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.

Renvoie
string
ce qu'elle imprime d'après son modèle, ou "recipe"
Brass
if imprimante.template() == nil then
  print("pas de modèle")
else
  print("mode " .. imprimante.mode())
end

Voir aussi printer.template() printer.cost()

#

imprimante.cost()

→ number|nil

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.

Renvoie
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 :

Brass
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")
end

Voir aussi printer.mode() tank.tanks()

#

imprimante.running()

→ boolean

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.

Renvoie
boolean
vrai pendant qu'elle imprime

Voir aussi printer.progress()

#

imprimante.progress()

→ number

L'avancement de l'impression en cours, de 0 à 1 : 1 quand la copie sort, 0 quand rien ne s'imprime.

Renvoie
number
l'avancement de la copie, de 0 à 1
Brass
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.

Brass
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)
end

En mode super, le niveau reste à 30 tant que NIVEAU ne demande pas plus : mettez-le à 60 pour profiter de toute la plage.