Enchantment Industry
The Blaze Enchanter, the Blaze Forger and the Printer of Create: Enchantment Industry driven by a computer: enchanting level, liquid experience, forging mode, results and copies.
The Blaze Enchanter, the Blaze Forger and the Printer are blocks of Create: Enchantment Industry (which itself needs Create: Dragons Plus). Without that mod, there is no such block, and peripheral.find("blaze_enchanter") returns nil.
Create: Enchantment Industry turns experience into a fluid and puts blazes to work with it. The Blaze Enchanter enchants the items it is given, like an enchanting table; the Blaze Forger merges, applies and extracts enchantments, like an anvil; the Printer copies a template (an enchanted book, a written book, a name...) onto the items passing under it. A computer connected to them sets the enchanting level and the forging mode, watches the experience of the blazes, and reads every item and every result: enough for an enchanting line that reports what it made, a gauge that calls for experience before it runs out, or a forge that changes its mode by itself.
| Block (in game) | peripheral type | what it reads or sets |
|---|---|---|
| Blaze Enchanter | blaze_enchanter | its experience and heat, the enchanting level, its item, what it can get, the cost |
| Blaze Forger | blaze_forger | its experience and heat, the forging mode, its inputs, outputs and result |
| Printer | printer | its template, what it prints, the fluid a copy takes, its progress |
Against the computer a block is called by its side ("left"...); on a Data Cable (Minicomputer and newer) it gets a name such as blaze_enchanter@12,64,-30. peripheral.find("blaze_forger") takes the first one.
local enchanter = peripheral.find("blaze_enchanter")
enchanter.set_level(30)
print(enchanter.experience() .. " mB of experience, heat " .. enchanter.heat())Both blazes have the same readings of their experience and of their work (the first section below). The enchanter adds the methods of its enchanting level, the forger those of its forging mode: set_mode exists only on a forger, set_level only on an enchanter. Each method says which blaze has it.
Every method reads the block again when it is called. When the block is gone, the call stops the program with blaze enchanter removed, blaze forger removed or printer removed; when its chunk is not loaded, with peripheral is not loaded. Another version of the mod that lacks a part gives this version of Create: Enchantment Industry has no ..., and an error of the mod itself Create: Enchantment Industry error: ....
Also tanks. A blaze keeps its experience in two tanks, which tank.tanks() (see Tanks) also reads, but only from below: the computer or the Data Cable must touch the bottom of the blaze, the face its pipe uses. tanks() then lists the liquid experience, then the super experience. A pipe usually takes that place, so experience() and super_experience() read the same from any side. The Printer's tank is seen from every side but the bottom.
Other blocks. The mod's other blocks, such as the Classic Blaze Enchanter, the Grindstone Drain or the Experience Lantern, have no methods of their own: at most the generic ones of a block that holds fluids or turns. The blocks it adds with Apotheosis or Apothic Enchanting (Blaze Composer, Affix Augmentor, Gem Cutter, Infuser, Brass Bookshelf...) have no peripheral of their own either.
blaze.heat() | How hot the blaze burns, from what its tanks hold: "smouldering" with no experience, "fading" under 1.25 % of its tank (50 mB of 4000), "kindled" above, and "seething" as soon as it holds super experience: that is super mode. Both blazes have it. |
blaze.creative() | true once a Creative Blaze Cake has fed the blaze: its tank becomes creative and stays full, so experience() (or super_experience()) reads its whole capacity. Both blazes have it. |
blaze.experience() | The liquid experience in the blaze's tank, in mB: the tank its pipe and the plain experience items fill. Outside super mode, a job is paid from it. Both blazes have it. |
blaze.super_experience() | The super experience of the blaze, in mB. More than 0 means super mode, where every job is paid from this tank only. Both blazes have it. |
blaze.experience_capacity() | How much each tank of the blaze holds, in mB: 4000 by default (server configs blazeEnchanterFluidCapacity and blazeForgerFluidCapacity). The super experience tank has the same size. Both blazes have it. |
blaze.cursed() | true while the blaze is in super mode with no open sky above it: no lightning can come, so no Lightning Rod is needed, but the next result is spoiled (a curse may come with an enchantment, a forged item costs more to repair). false outside super mode. Both blazes have it. |
blaze.running() | true during the 10 seconds of a job; false while the blaze waits for an item, for experience, or for its result to be taken. Both blazes have it. |
blaze.progress() | How far the current job is, from 0 to 1; 0 when nothing runs. Both blazes have it. |
blaze.problem() | Why the blaze does not work, as one word: |
enchanter.level() | The level set on the enchanter, from 0 (not set: it does not enchant) to max_level(). Blaze Enchanter only. |
enchanter.max_level() | The highest level the enchanter takes now: 30 by default, 60 in super mode (server configs blazeEnchanterMaxEnchantLevel and blazeEnchanterMaxSuperEnchantLevel). It changes as soon as super experience comes in or runs out. Blaze Enchanter only. |
enchanter.set_level(level) | Sets the value box, like a player, at the end of the tick, and returns the level kept: between 0 and max_level(). 0 stops the enchanting. The number must be whole: set_level(12.5) stops the program with bad argument #1 to 'set_level' (number has no integer representation). Blaze Enchanter only. |
enchanter.item() | The item on the enchanter, before or after its enchanting. Blaze Enchanter only. The table has the fields of every item of this page (the template, the inputs and outputs of the forger, the printer's template): |
enchanter.template() | The item set on the slot of its front, which puts the enchanter in template mode (see above), as an item table like blaze.item(). nil without template: the enchanter then enchants the item itself. Only a player sets it. Blaze Enchanter only. |
enchanter.enchantments() | What the held item can get at this level and heat (in template mode, what the template can get): the list Engineer's Goggles show. The result draws some of them. In super mode under a covered sky, the curses that may be added are in the list too, with curse = true. Empty when the enchanter holds nothing. Blaze Enchanter only. |
enchanter.cost() | What enchanting the held item costs at this level and heat, in mB (experience points): the cost Engineer's Goggles show. In super mode, it is paid in super experience. nil when the enchanter holds nothing or the job costs nothing (level 0). Blaze Enchanter only. |
enchanter.done() | true from the end of a job until a player or an arm takes the item, which item() then shows with its enchantments. To count the results, wait for done(), then for it to turn false again. Blaze Enchanter only. |
forger.mode() | The forging mode of the value box. A new forger starts in "merge". Blaze Forger only. |
forger.set_mode(mode) | Sets the value box, like a player, at the end of the tick. A job under way stops, and the result is worked out again for the new mode. Upper case is accepted; another word stops the program with bad argument #1 to 'set_mode' (merge, apply, extract). Returns nothing. Blaze Forger only. |
forger.inputs() | What sits in its two inputs: first the item worked on, second what is added to it (see the table above). Each is an item table like blaze.item(), or nil when that input is empty. Both empty when a job ends. Blaze Forger only. |
forger.outputs() | The results waiting in its two outputs: first the main result, second the filled template of an extraction. Each is an item table, or nil. While either holds something, the forger takes no new item. Blaze Forger only. |
forger.result() | What the forger has worked out for its inputs and mode, before the job: first and second the items it will put in its outputs (item tables, or nil), cost the experience it costs in mB, levels that cost in levels, like an anvil's. nil when an input is missing or the two make nothing: blaze.problem() tells which. Blaze Forger only. |
printer.template() | The template of the printer, as an item table like blaze.item(): an enchanted book shows its enchantments. nil without template. Only a player sets it. |
printer.mode() | Which line of the table above its template gives: "enchanted_book", "written_book", "custom_name", "copy", "package_address", "package_pattern" or "banner_pattern"; "other" for a kind an addon adds. For any other template, "recipe": the printer then follows the printing recipes of data packs or other mods (Enchantment Industry ships none). It is "recipe" without template too, when the printer prints nothing: test template() to tell them apart. |
printer.cost() | How much fluid one copy takes, with the fluid now in its tank, in mB (see the table above; for an enchanted book, as many mB of liquid experience as its enchantments are worth in points). nil when the tank is empty or its fluid does not print this template, and in "recipe" mode, where each recipe has its own cost. |
printer.running() | true from the start of a print until the copy comes out; false otherwise, also while an item waits under it for fluid. |
printer.progress() | How far the current print is, from 0 to 1: 1 when the copy comes out, 0 when nothing prints. |
Liquid experience and heat
Both blazes burn liquid experience: 1 mB is 1 experience point, so the 4000 mB tank of a blaze (by default, server configs blazeEnchanterFluidCapacity and blazeForgerFluidCapacity) holds 4000 points. It comes in by a pipe under the blaze (from below only), or from items given by hand or by a Mechanical Arm: a Bucket o' Enchanting (1000 mB), Create's Experience Nugget (3) and Block of Experience (27). How much is left sets its heat, blaze.heat().
Super experience. A second tank of the same size holds super experience. It comes only from items, never by pipe: Nugget of Super Experience (3), Block of Super Experience (27), Cake Slice o' Enchanting (250), Cake o' Enchanting (1000). While a blaze holds some, it is seething and works in super mode, paying with its super experience only:
- the enchanter goes up to level 60 instead of 30 (server configs
blazeEnchanterMaxSuperEnchantLevelandblazeEnchanterMaxEnchantLevel), can give treasure enchantments such as Mending, and puts enchantments one level above their usual maximum (except Mending and Infinity); - the forger also raises levels one above their maximum, and can extract curses;
- both ignore the incompatibilities between enchantments (server config
ignoreEnchantmentCompatibility).
The lightning of super mode. A job in super mode ends by calling a lightning bolt down onto the blaze. That needs an open sky: no block above the blaze (glass counts), in a dimension that has a sky.
- Under an open sky, the bolt goes to a Lightning Rod within 128 blocks that is the highest block of its column, and the job completes.
- Under a covered sky (or in the Nether, the End), there is no bolt, but the result is spoiled: the enchanter may add a curse to it (one roll, 1 chance in 2 by default), the forger raises its repair cost as one more use of an anvil would.
blaze.cursed()tells when.
Under an open sky without a Lightning Rod in reach, the bolt strikes the blaze itself: the block is destroyed, and only a Lit Blaze Burner, without its blaze, is left in its place.
A job takes 10 seconds (200 ticks). The blaze starts only when it holds enough experience for the cost, pays at the end, and starts over if it runs short meanwhile.
blaze.heat()
How hot the blaze burns, from what its tanks hold: "smouldering" with no experience, "fading" under 1.25 % of its tank (50 mB of 4000), "kindled" above, and "seething" as soon as it holds super experience: that is super mode. Both blazes have it.
- string
- "smouldering", "fading", "kindled" or "seething"
local blaze = peripheral.find("blaze_enchanter")
if blaze.heat() == "seething" then
print("super mode, up to level " .. blaze.max_level())
endblaze.creative()
true once a Creative Blaze Cake has fed the blaze: its tank becomes creative and stays full, so experience() (or super_experience()) reads its whole capacity. Both blazes have it.
- boolean
- true when the blaze has eaten a Creative Blaze Cake
blaze.experience()
The liquid experience in the blaze's tank, in mB: the tank its pipe and the plain experience items fill. Outside super mode, a job is paid from it. Both blazes have it.
- number
- the liquid experience in its tank, in mB (1 mB is 1 point)
An experience gauge that asks for more before the tank runs dry:
local blaze = peripheral.find("blaze_forger")
local share = blaze.experience() / blaze.experience_capacity()
print(math.floor(share * 100) .. " % of experience")
if share < 0.1 then
print("feed the forger")
endSee also blaze.experience_capacity() blaze.super_experience()
blaze.super_experience()
The super experience of the blaze, in mB. More than 0 means super mode, where every job is paid from this tank only. Both blazes have it.
- number
- the super experience in its second tank, in mB
if blaze.super_experience() > 0 then
print(blaze.super_experience() .. " mB of super experience")
endSee also blaze.heat() blaze.cursed()
blaze.experience_capacity()
How much each tank of the blaze holds, in mB: 4000 by default (server configs blazeEnchanterFluidCapacity and blazeForgerFluidCapacity). The super experience tank has the same size. Both blazes have it.
- number
- the size of each of its two tanks, in mB
blaze.cursed()
true while the blaze is in super mode with no open sky above it: no lightning can come, so no Lightning Rod is needed, but the next result is spoiled (a curse may come with an enchantment, a forged item costs more to repair). false outside super mode. Both blazes have it.
- boolean
- true in super mode under a covered sky
if blaze.cursed() then
print("super mode under a roof: open the sky")
endSee also blaze.super_experience()
blaze.running()
true during the 10 seconds of a job; false while the blaze waits for an item, for experience, or for its result to be taken. Both blazes have it.
- boolean
- true while a job runs
See also blaze.progress() blaze.problem()
blaze.progress()
How far the current job is, from 0 to 1; 0 when nothing runs. Both blazes have it.
- number
- how far the job is, from 0 to 1
local done = math.floor(blaze.progress() * 20)
print("[" .. string.rep("#", done) .. string.rep(".", 20 - done) .. "]")See also blaze.running()
blaze.problem()
Why the blaze does not work, as one word:
- string|nil
- why the blaze waits; nil when nothing stops it
| value | blaze | meaning |
|---|---|---|
"level_not_set" | enchanter | it holds an item, but its level is 0 |
"invalid_item" | enchanter | its item cannot be enchanted at this level and heat (a Super Enchanting Template outside super mode...) |
"incomplete_input" | forger | one of its two inputs is empty |
"invalid" | forger | its two inputs make nothing in this mode (Engineer's Goggles tell why) |
"output_blocked" | forger | a result waits in its outputs |
"not_enough_experience" | both | the job costs more than it holds (more than its super experience, in super mode) |
nil when nothing stops it, and also when there is nothing to do: an empty blaze, or an enchanter whose item is done. Both blazes have it.
local p = blaze.problem()
rs.set("top", p == "not_enough_experience") -- a lamp calls for experienceSee also blaze.running()
Blaze Enchanter
The Blaze Enchanter takes one item at a time, given by hand or by a Mechanical Arm, and enchants it at the level of its value box (Enchanting Level). That level is the one of an enchanting table: it decides which enchantments can come and how strong they are, from 1 to 30 (60 in super mode). The result is drawn at random among them, as at a table. The cost grows with the level: 27 mB at level 10, 321 mB at level 30, 2157 mB at level 60 with the default settings (blaze.cost() gives it exactly). At level 0, it does nothing. The enchanted item waits on the blaze until a player or an arm takes it (blaze.done()).
Template mode. An enchantable item clicked on the slot of its front becomes its template (blaze.template()): the blaze then no longer enchants items, but writes enchantments the template could get into blank Enchanting Templates (Super Enchanting Templates in super mode), which a forger applies later. An empty hand on the slot takes the template away.
enchanter.level()
The level set on the enchanter, from 0 (not set: it does not enchant) to max_level(). Blaze Enchanter only.
- number
- the enchanting level of its value box, 0 when not set
local enchanter = peripheral.find("blaze_enchanter")
print("level " .. enchanter.level() .. " of " .. enchanter.max_level())See also blaze.set_level() blaze.max_level()
enchanter.max_level()
The highest level the enchanter takes now: 30 by default, 60 in super mode (server configs blazeEnchanterMaxEnchantLevel and blazeEnchanterMaxSuperEnchantLevel). It changes as soon as super experience comes in or runs out. Blaze Enchanter only.
- number
- the highest level it takes now, 30 or 60 by default
See also blaze.set_level()
enchanter.set_level(level)
Sets the value box, like a player, at the end of the tick, and returns the level kept: between 0 and max_level(). 0 stops the enchanting. The number must be whole: set_level(12.5) stops the program with bad argument #1 to 'set_level' (number has no integer representation). Blaze Enchanter only.
levelnumber- the new level, a whole number
- number
- the level kept, between 0 and max_level()
local enchanter = peripheral.find("blaze_enchanter")
print(enchanter.set_level(99))Outside super mode this prints 30: ask for too much to get the highest level.
See also blaze.level() blaze.cost()
enchanter.item()
The item on the enchanter, before or after its enchanting. Blaze Enchanter only. The table has the fields of every item of this page (the template, the inputs and outputs of the forger, the printer's template):
- table|nil
- the item it holds, {name =, count =, display =, enchantments =}; nil when empty
| field | content |
|---|---|
name | the item id, like "minecraft:book" |
count | how many (1 on a blaze) |
display | the name a player sees |
enchantments | its enchantments (a book's or a template's too), a list of {name =, level =, curse =}; missing when it has none |
In enchantments, name is the id of the enchantment ("minecraft:sharpness"), level its level, and curse is true for a curse.
local it = enchanter.item()
if it and it.enchantments then
for _, en in ipairs(it.enchantments) do
print(en.name .. " " .. en.level)
end
endSee also blaze.done() blaze.enchantments()
enchanter.template()
The item set on the slot of its front, which puts the enchanter in template mode (see above), as an item table like blaze.item(). nil without template: the enchanter then enchants the item itself. Only a player sets it. Blaze Enchanter only.
- table|nil
- its template, an item table; nil without template
What the held item can get at this level and heat (in template mode, what the template can get): the list Engineer's Goggles show. The result draws some of them. In super mode under a covered sky, the curses that may be added are in the list too, with curse = true. Empty when the enchanter holds nothing. Blaze Enchanter only.
- table
- the enchantments it can give, a list of {name =, level =, curse =}
for _, en in ipairs(enchanter.enchantments()) do
print(en.name .. " " .. en.level)
endSee also blaze.item()
enchanter.cost()
What enchanting the held item costs at this level and heat, in mB (experience points): the cost Engineer's Goggles show. In super mode, it is paid in super experience. nil when the enchanter holds nothing or the job costs nothing (level 0). Blaze Enchanter only.
- number|nil
- the experience the job will cost, in mB; nil without item
local need = enchanter.cost()
if need and need > enchanter.experience() then
print("missing " .. (need - enchanter.experience()) .. " mB")
endSee also blaze.set_level() blaze.experience()
enchanter.done()
true from the end of a job until a player or an arm takes the item, which item() then shows with its enchantments. To count the results, wait for done(), then for it to turn false again. Blaze Enchanter only.
- boolean
- true when the enchanted item waits to be taken
See also blaze.item()
Blaze Forger
The Blaze Forger does the work of an anvil with experience. It has two inputs and two outputs: items come in by hand or by a Mechanical Arm, and the results wait in the outputs until they are taken. While one waits, the forger takes nothing new (problem() gives "output_blocked"). Its value box (Forging Mode) chooses what it does:
| mode | first input | second input | result |
|---|---|---|---|
"merge" | an item | the same item; or two enchanted books; or two filled templates of one kind | the first, with the enchantments of both (and repaired, for a worn tool) |
"apply" | the item to enchant, or a Book | an enchanted book or a filled Enchanting Template | the item with those enchantments (a template on a Book gives an enchanted book) |
"extract" | an item, book or template with enchantments | a blank Enchanting Template | the source without one enchantment, and the template that holds it |
As at an anvil, a level goes up only when two equal levels meet (Sharpness III and III give IV), and never above the maximum of the enchantment outside super mode. The cost is counted in levels, like an anvil's, and the forger pays the experience points of those levels counted from 0: 55 mB for 5 levels, 160 mB for 10. Templates must match the heat: Super Enchanting Templates only in super mode, plain ones only outside it.
forger.mode()
The forging mode of the value box. A new forger starts in "merge". Blaze Forger only.
- string
- "merge", "apply" or "extract"
local forger = peripheral.find("blaze_forger")
print(forger.mode())See also blaze.set_mode()
forger.set_mode(mode)
Sets the value box, like a player, at the end of the tick. A job under way stops, and the result is worked out again for the new mode. Upper case is accepted; another word stops the program with bad argument #1 to 'set_mode' (merge, apply, extract). Returns nothing. Blaze Forger only.
modestring- "merge", "apply" or "extract"
forger.set_mode("extract")
sleep(0) -- the mode changes at the end of the tick
print(forger.mode())See also blaze.mode() blaze.result()
forger.inputs()
What sits in its two inputs: first the item worked on, second what is added to it (see the table above). Each is an item table like blaze.item(), or nil when that input is empty. Both empty when a job ends. Blaze Forger only.
- table
- {first =, second =}, the items in its two inputs
local i = forger.inputs()
print(i.first and i.first.display or "empty", i.second and i.second.display or "empty")See also blaze.outputs() blaze.result()
forger.outputs()
The results waiting in its two outputs: first the main result, second the filled template of an extraction. Each is an item table, or nil. While either holds something, the forger takes no new item. Blaze Forger only.
- table
- {first =, second =}, the results waiting to be taken
See also blaze.inputs()
forger.result()
What the forger has worked out for its inputs and mode, before the job: first and second the items it will put in its outputs (item tables, or nil), cost the experience it costs in mB, levels that cost in levels, like an anvil's. nil when an input is missing or the two make nothing: blaze.problem() tells which. Blaze Forger only.
- table|nil
- {first =, second =, cost =, levels =}, what its inputs will make; nil when they make nothing
local r = forger.result()
if r then
print(r.first.display .. ": " .. r.levels .. " levels, " .. r.cost .. " mB")
endSee also blaze.problem() blaze.set_mode()
Printer
The Printer sits above a belt or a depot, like a Spout, and prints onto the items they bring under it, paying with the fluid of its tank (4000 mB by default, server config printerFluidCapacity, filled by pipe from every side but the bottom). What it prints comes from its template: a copy of the item a player clicks on the slot of its front. A print takes 2.5 seconds (50 ticks). An item the template does not apply to passes by, as with a fluid that does not print; an item it can print waits under it until the tank holds enough.
| mode | template | prints onto | fluid per copy |
|---|---|---|---|
"enchanted_book" | an Enchanted Book | Books | liquid experience, by its enchantments |
"written_book" | a Written Book | Books | black dye, 10 mB per page |
"custom_name" | a Name Tag with a name | any item | a dye, 250 mB (the name takes its colour), or liquid experience, 10 mB |
"copy" | a Create item that can be copied (a Clipboard...), or a Schematic | the same item (Empty Schematics for a Schematic) | black dye, 10 mB |
"package_address" | a Package with an address | packages | black dye, 10 mB |
"package_pattern" | a Package without address | other packages, which take its look | black dye, 100 mB |
"banner_pattern" | a banner with one pattern | banners | a dye, 100 mB (the pattern takes its colour) |
The dyes are the liquid dyes of Create: Dragons Plus.
printer.template()
The template of the printer, as an item table like blaze.item(): an enchanted book shows its enchantments. nil without template. Only a player sets it.
- table|nil
- its template, {name =, count =, display =, enchantments =}; nil without template
local printer = peripheral.find("printer")
local t = printer.template()
if t then
print("prints " .. t.display)
endSee also printer.mode()
printer.mode()
Which line of the table above its template gives: "enchanted_book", "written_book", "custom_name", "copy", "package_address", "package_pattern" or "banner_pattern"; "other" for a kind an addon adds. For any other template, "recipe": the printer then follows the printing recipes of data packs or other mods (Enchantment Industry ships none). It is "recipe" without template too, when the printer prints nothing: test template() to tell them apart.
- string
- what it prints from its template, or "recipe"
if printer.template() == nil then
print("no template")
else
print("mode " .. printer.mode())
endSee also printer.template() printer.cost()
printer.cost()
How much fluid one copy takes, with the fluid now in its tank, in mB (see the table above; for an enchanted book, as many mB of liquid experience as its enchantments are worth in points). nil when the tank is empty or its fluid does not print this template, and in "recipe" mode, where each recipe has its own cost.
- number|nil
- the fluid one copy takes with what its tank holds, in mB; nil if that fluid does not print
With tank.tanks() (the computer beside or above the printer), the copies left:
local printer = peripheral.find("printer")
local each = printer.cost()
if each then
print(math.floor(printer.tanks()[1].amount / each) .. " copies left")
else
print("this fluid does not print it")
endSee also printer.mode() tank.tanks()
printer.running()
true from the start of a print until the copy comes out; false otherwise, also while an item waits under it for fluid.
- boolean
- true while it prints
See also printer.progress()
printer.progress()
How far the current print is, from 0 to 1: 1 when the copy comes out, 0 when nothing prints.
- number
- how far the copy is, from 0 to 1
print(math.floor(printer.progress() * 100) .. " %")See also printer.running()
An enchanting station
A complete little program: a Blaze Enchanter on the left of the computer, fed with books by a Mechanical Arm that also takes them away, and a lamp on top of the computer. The computer keeps the level at 30 (or at the highest, if it is lower), prints every book it makes with its enchantments, says why the blaze waits, and lights the lamp when experience is missing. It looks ten times a second, so that it sees each result before the arm takes it.
local enchanter = peripheral.wrap("left")
local LEVEL = 30
local made = 0
local shown = nil
local function names(item)
local list = {}
for _, en in ipairs(item.enchantments or {}) do
local text = en.name .. " " .. en.level
if en.curse then
text = text .. " (curse)"
end
table.insert(list, text)
end
return table.concat(list, ", ")
end
while true do
if enchanter.level() ~= math.min(LEVEL, enchanter.max_level()) then
enchanter.set_level(LEVEL)
end
if enchanter.done() then
local item = enchanter.item()
if item then
made = made + 1
print(made .. ". " .. item.display .. ": " .. names(item))
end
while enchanter.done() do -- until the arm takes it
sleep(0.1)
end
end
local problem = enchanter.problem()
if problem ~= shown then
if problem then
print("waiting: " .. problem)
end
shown = problem
end
rs.set("top", problem == "not_enough_experience")
sleep(0.1)
endIn super mode the level stays at 30 unless LEVEL asks for more: set it to 60 to use the whole range.