"explode" all modpacks into their individual components

(you can't have a modpack buried inside a modpack)

8 files changed, 1313 insertions, 0 deletions

diff --git a/technic/machines/HV/battery_box.lua b/technic/machines/HV/battery_box.lua
new file mode 100644
index 0000000..1e054ec
--- /dev/null
+++ b/technic/machines/HV/battery_box.lua
@@ -0,0 +1,21 @@
+-- HV battery box
+minetest.register_craft({
+	output = 'technic:hv_battery_box0',
+	recipe = {
+		{'technic:mv_battery_box0', 'technic:mv_battery_box0', 'technic:mv_battery_box0'},
+		{'technic:mv_battery_box0', 'technic:hv_transformer',  'technic:mv_battery_box0'},
+		{'',                        'technic:hv_cable0',       ''},
+	}
+})
+
+technic.register_battery_box({
+	tier           = "HV",
+	max_charge     = 1000000,
+	charge_rate    = 100000,
+	discharge_rate = 400000,
+	charge_step    = 10000,
+	discharge_step = 40000,
+	upgrade        = 1,
+	tube           = 1,
+})
+
diff --git a/technic/machines/HV/cables.lua b/technic/machines/HV/cables.lua
new file mode 100644
index 0000000..25297c8
--- /dev/null
+++ b/technic/machines/HV/cables.lua
@@ -0,0 +1,12 @@
+
+minetest.register_craft({
+	output = 'technic:hv_cable0 3',
+	recipe = {
+		{'homedecor:plastic_sheeting', 'homedecor:plastic_sheeting', 'homedecor:plastic_sheeting'},
+		{'technic:mv_cable0',          'technic:mv_cable0',          'technic:mv_cable0'},
+		{'homedecor:plastic_sheeting', 'homedecor:plastic_sheeting', 'homedecor:plastic_sheeting'},
+	}
+}) 
+
+technic.register_cable("HV", 3/16)
+
diff --git a/technic/machines/HV/forcefield.lua b/technic/machines/HV/forcefield.lua
new file mode 100644
index 0000000..0f0836d
--- /dev/null
+++ b/technic/machines/HV/forcefield.lua
@@ -0,0 +1,261 @@
+--- Forcefield generator.
+-- @author ShadowNinja
+--
+-- Forcefields are powerful barriers but they consume huge amounts of power.
+-- The forcefield Generator is an HV machine.
+
+-- How expensive is the generator?
+-- Leaves room for upgrades lowering the power drain?
+local forcefield_power_drain   = 10
+
+local S = technic.getter
+
+minetest.register_craft({
+	output = "technic:forcefield_emitter_off",
+	recipe = {
+			{"default:mese",         "technic:motor",          "default:mese"        },
+			{"technic:deployer_off", "technic:machine_casing", "technic:deployer_off"},
+			{"default:mese",         "technic:hv_cable0",      "default:mese"        },
+	}
+})
+
+
+local replaceable_cids = {}
+
+minetest.after(0, function()
+	for name, ndef in pairs(minetest.registered_nodes) do
+		if ndef.buildable_to == true and name ~= "ignore" then
+			replaceable_cids[minetest.get_content_id(name)] = true
+		end
+	end
+end)
+
+
+-- Idea: Let forcefields have different colors by upgrade slot.
+-- Idea: Let forcefields add up by detecting if one hits another.
+--    ___   __
+--   /   \/   \
+--  |          |
+--   \___/\___/
+
+local function update_forcefield(pos, meta, active, first)
+	local shape = meta:get_int("shape")
+	local range = meta:get_int("range")
+	local vm = VoxelManip()
+	local MinEdge, MaxEdge = vm:read_from_map(vector.subtract(pos, range),
+			vector.add(pos, range))
+	local area = VoxelArea:new({MinEdge = MinEdge, MaxEdge = MaxEdge})
+	local data = vm:get_data()
+
+	local c_air = minetest.get_content_id("air")
+	local c_field = minetest.get_content_id("technic:forcefield")
+
+	for z = -range, range do
+	for y = -range, range do
+	local vi = area:index(pos.x + (-range), pos.y + y, pos.z + z)
+	for x = -range, range do
+		local relevant
+		if shape == 0 then
+			local squared = x * x + y * y + z * z
+			relevant =
+				squared <= range       *  range      +  range and
+				squared >= (range - 1) * (range - 1) + (range - 1)
+		else
+			relevant =
+				x == -range or x == range or
+				y == -range or y == range or
+				z == -range or z == range
+		end
+		if relevant then
+			local cid = data[vi]
+			if active and replaceable_cids[cid] then
+				data[vi] = c_field
+			elseif not active and cid == c_field then
+				data[vi] = c_air
+			end
+		end
+		vi = vi + 1
+	end
+	end
+	end
+
+	vm:set_data(data)
+	vm:update_liquids()
+	vm:write_to_map()
+	-- update_map is very slow, but if we don't call it we'll
+	-- get phantom blocks on the client.
+	if not active or first then
+		vm:update_map()
+	end
+end
+
+local function set_forcefield_formspec(meta)
+	local formspec = "size[5,2.25]"..
+		"field[0.3,0.5;2,1;range;"..S("Range")..";"..meta:get_int("range").."]"
+	-- The names for these toggle buttons are explicit about which
+	-- state they'll switch to, so that multiple presses (arising
+	-- from the ambiguity between lag and a missed press) only make
+	-- the single change that the user expects.
+	if meta:get_int("shape") == 0 then
+		formspec = formspec.."button[3,0.2;2,1;shape1;"..S("Sphere").."]"
+	else
+		formspec = formspec.."button[3,0.2;2,1;shape0;"..S("Cube").."]"
+	end
+	if meta:get_int("mesecon_mode") == 0 then
+		formspec = formspec.."button[0,1;5,1;mesecon_mode_1;"..S("Ignoring Mesecon Signal").."]"
+	else
+		formspec = formspec.."button[0,1;5,1;mesecon_mode_0;"..S("Controlled by Mesecon Signal").."]"
+	end
+	if meta:get_int("enabled") == 0 then
+		formspec = formspec.."button[0,1.75;5,1;enable;"..S("%s Disabled"):format(S("%s Forcefield Emitter"):format("HV")).."]"
+	else
+		formspec = formspec.."button[0,1.75;5,1;disable;"..S("%s Enabled"):format(S("%s Forcefield Emitter"):format("HV")).."]"
+	end
+	meta:set_string("formspec", formspec)
+end
+
+local forcefield_receive_fields = function(pos, formname, fields, sender)
+	local meta = minetest.get_meta(pos)
+	local range = nil
+	if fields.range then
+		range = tonumber(fields.range) or 0
+		-- Smallest field is 5. Anything less is asking for trouble.
+		-- Largest is 20. It is a matter of pratical node handling.
+		-- At the maximim range updating the forcefield takes about 0.2s
+		range = math.max(range, 5)
+		range = math.min(range, 20)
+		if range == meta:get_int("range") then range = nil end
+	end
+	if fields.shape0 or fields.shape1 or range then
+		update_forcefield(pos, meta, false)
+	end
+	if range then meta:set_int("range", range) end
+	if fields.shape0 then meta:set_int("shape", 0) end
+	if fields.shape1 then meta:set_int("shape", 1) end
+	if fields.enable then meta:set_int("enabled", 1) end
+	if fields.disable then meta:set_int("enabled", 0) end
+	if fields.mesecon_mode_0 then meta:set_int("mesecon_mode", 0) end
+	if fields.mesecon_mode_1 then meta:set_int("mesecon_mode", 1) end
+	set_forcefield_formspec(meta)
+end
+
+local mesecons = {
+	effector = {
+		action_on = function(pos, node)
+			minetest.get_meta(pos):set_int("mesecon_effect", 1)
+		end,
+		action_off = function(pos, node)
+			minetest.get_meta(pos):set_int("mesecon_effect", 0)
+		end
+	}
+}
+
+local function run(pos, node)
+	local meta = minetest.get_meta(pos)
+	local eu_input   = meta:get_int("HV_EU_input")
+	local enabled = meta:get_int("enabled") ~= 0 and (meta:get_int("mesecon_mode") == 0 or meta:get_int("mesecon_effect") ~= 0)
+	local machine_name = S("%s Forcefield Emitter"):format("HV")
+
+	local range = meta:get_int("range")
+	local power_requirement
+	if meta:get_int("shape") == 0 then
+		power_requirement = math.floor(4 * math.pi * range * range)
+	else
+		power_requirement = 24 * range * range
+	end
+	power_requirement = power_requirement * forcefield_power_drain
+
+	if not enabled then
+		if node.name == "technic:forcefield_emitter_on" then
+			update_forcefield(pos, meta, false)
+			technic.swap_node(pos, "technic:forcefield_emitter_off")
+			meta:set_string("infotext", S("%s Disabled"):format(machine_name))
+		end
+		meta:set_int("HV_EU_demand", 0)
+		return
+	end
+	meta:set_int("HV_EU_demand", power_requirement)
+	if eu_input < power_requirement then
+		meta:set_string("infotext", S("%s Unpowered"):format(machine_name))
+		if node.name == "technic:forcefield_emitter_on" then
+			update_forcefield(pos, meta, false)
+			technic.swap_node(pos, "technic:forcefield_emitter_off")
+		end
+	elseif eu_input >= power_requirement then
+		local first = false
+		if node.name == "technic:forcefield_emitter_off" then
+			first = true
+			technic.swap_node(pos, "technic:forcefield_emitter_on")
+			meta:set_string("infotext", S("%s Active"):format(machine_name))
+		end
+		update_forcefield(pos, meta, true, first)
+	end
+end
+
+minetest.register_node("technic:forcefield_emitter_off", {
+	description = S("%s Forcefield Emitter"):format("HV"),
+	tiles = {"technic_forcefield_emitter_off.png"},
+	groups = {cracky = 1, technic_machine = 1},
+	on_receive_fields = forcefield_receive_fields,
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_int("HV_EU_input", 0)
+		meta:set_int("HV_EU_demand", 0)
+		meta:set_int("range", 10)
+		meta:set_int("enabled", 0)
+		meta:set_int("mesecon_mode", 0)
+		meta:set_int("mesecon_effect", 0)
+		meta:set_string("infotext", S("%s Forcefield Emitter"):format("HV"))
+		set_forcefield_formspec(meta)
+	end,
+	mesecons = mesecons,
+	technic_run = run,
+})
+
+minetest.register_node("technic:forcefield_emitter_on", {
+	description = S("%s Forcefield Emitter"):format("HV"),
+	tiles = {"technic_forcefield_emitter_on.png"},
+	groups = {cracky = 1, technic_machine = 1, not_in_creative_inventory=1},
+	drop = "technic:forcefield_emitter_off",
+	on_receive_fields = forcefield_receive_fields,
+	on_destruct = function(pos)
+		local meta = minetest.get_meta(pos)
+		update_forcefield(pos, meta, false)
+	end,
+	mesecons = mesecons,
+	technic_run = run,
+	technic_on_disable = function (pos, node)
+		local meta = minetest.get_meta(pos)
+		update_forcefield(pos, meta, false)
+		technic.swap_node(pos, "technic:forcefield_emitter_off")
+	end,
+})
+
+minetest.register_node("technic:forcefield", {
+	description = S("%s Forcefield"):format("HV"),
+	sunlight_propagates = true,
+	drawtype = "glasslike",
+	groups = {not_in_creative_inventory=1},
+	paramtype = "light",
+        light_source = 15,
+	diggable = false,
+	drop = '',
+	tiles = {{
+		name = "technic_forcefield_animated.png",
+		animation = {
+			type = "vertical_frames",
+			aspect_w = 16,
+			aspect_h = 16,
+			length = 1.0,
+		},
+	}},
+})
+
+
+if minetest.get_modpath("mesecons_mvps") then
+	mesecon.register_mvps_stopper("technic:forcefield")
+end
+
+technic.register_machine("HV", "technic:forcefield_emitter_on",  technic.receiver)
+technic.register_machine("HV", "technic:forcefield_emitter_off", technic.receiver)
+
diff --git a/technic/machines/HV/generator.lua b/technic/machines/HV/generator.lua
new file mode 100644
index 0000000..aa83590
--- /dev/null
+++ b/technic/machines/HV/generator.lua
@@ -0,0 +1,13 @@
+minetest.register_alias("hv_generator", "technic:hv_generator")
+
+minetest.register_craft({
+	output = 'technic:hv_generator',
+	recipe = {
+		{'technic:carbon_plate',          'technic:mv_generator',   'technic:composite_plate'},
+		{'pipeworks:tube_1',              'technic:hv_transformer', 'pipeworks:tube_1'},
+		{'technic:stainless_steel_ingot', 'technic:hv_cable0',      'technic:stainless_steel_ingot'},
+	}
+})
+
+technic.register_generator({tier="HV", tube=1, supply=1200})
+
diff --git a/technic/machines/HV/init.lua b/technic/machines/HV/init.lua
new file mode 100644
index 0000000..d7136b4
--- /dev/null
+++ b/technic/machines/HV/init.lua
@@ -0,0 +1,18 @@
+
+technic.register_tier("HV", "High Voltage")
+
+local path = technic.modpath.."/machines/HV"
+
+-- Wiring stuff
+dofile(path.."/cables.lua")
+dofile(path.."/battery_box.lua")
+
+-- Generators
+dofile(path.."/solar_array.lua")
+dofile(path.."/nuclear_reactor.lua")
+dofile(path.."/generator.lua")
+
+-- Machines
+dofile(path.."/quarry.lua")
+dofile(path.."/forcefield.lua")
+
diff --git a/technic/machines/HV/nuclear_reactor.lua b/technic/machines/HV/nuclear_reactor.lua
new file mode 100644
index 0000000..3aa1ba8
--- /dev/null
+++ b/technic/machines/HV/nuclear_reactor.lua
@@ -0,0 +1,723 @@
+-- The enriched uranium rod driven EU generator.
+-- A very large and advanced machine providing vast amounts of power.
+-- Very efficient but also expensive to run as it needs uranium. (10000EU 86400 ticks (one week))
+-- Provides HV EUs that can be down converted as needed.
+--
+-- The nuclear reactor core needs water and a protective shield to work.
+-- This is checked now and then and if the machine is tampered with... BOOM!
+
+local burn_ticks   = 7 * 24 * 60 * 60       -- (seconds).
+local power_supply = 100000                 -- EUs
+local fuel_type    = "technic:uranium_fuel" -- The reactor burns this stuff
+
+local S = technic.getter
+
+if not vector.length_square then
+	vector.length_square = function (v)
+		return v.x*v.x + v.y*v.y + v.z*v.z
+	end
+end
+
+-- FIXME: recipe must make more sense like a rod recepticle, steam chamber, HV generator?
+minetest.register_craft({
+	output = 'technic:hv_nuclear_reactor_core',
+	recipe = {
+		{'technic:carbon_plate',          'default:obsidian_glass', 'technic:carbon_plate'},
+		{'technic:composite_plate',       'technic:machine_casing', 'technic:composite_plate'},
+		{'technic:stainless_steel_ingot',      'technic:hv_cable0', 'technic:stainless_steel_ingot'},
+	}
+})
+
+local generator_formspec =
+	"invsize[8,9;]"..
+	"label[0,0;"..S("Nuclear Reactor Rod Compartment").."]"..
+	"list[current_name;src;2,1;3,2;]"..
+	"list[current_player;main;0,5;8,4;]"..
+	"listring[]"
+
+-- "Boxy sphere"
+local nodebox = {
+	{ -0.353, -0.353, -0.353, 0.353, 0.353, 0.353 }, -- Box
+	{ -0.495, -0.064, -0.064, 0.495, 0.064, 0.064 }, -- Circle +-x
+	{ -0.483, -0.128, -0.128, 0.483, 0.128, 0.128 },
+	{ -0.462, -0.191, -0.191, 0.462, 0.191, 0.191 },
+	{ -0.433, -0.249, -0.249, 0.433, 0.249, 0.249 },
+	{ -0.397, -0.303, -0.303, 0.397, 0.303, 0.303 },
+	{ -0.305, -0.396, -0.305, 0.305, 0.396, 0.305 }, -- Circle +-y
+	{ -0.250, -0.432, -0.250, 0.250, 0.432, 0.250 },
+	{ -0.191, -0.461, -0.191, 0.191, 0.461, 0.191 },
+	{ -0.130, -0.482, -0.130, 0.130, 0.482, 0.130 },
+	{ -0.066, -0.495, -0.066, 0.066, 0.495, 0.066 },
+	{ -0.064, -0.064, -0.495, 0.064, 0.064, 0.495 }, -- Circle +-z
+	{ -0.128, -0.128, -0.483, 0.128, 0.128, 0.483 },
+	{ -0.191, -0.191, -0.462, 0.191, 0.191, 0.462 },
+	{ -0.249, -0.249, -0.433, 0.249, 0.249, 0.433 },
+	{ -0.303, -0.303, -0.397, 0.303, 0.303, 0.397 },
+}
+
+local reactor_siren = {}
+local function siren_set_state(pos, newstate)
+	local hpos = minetest.hash_node_position(pos)
+	local siren = reactor_siren[hpos]
+	if not siren then
+		if newstate == "off" then return end
+		siren = {state="off"}
+		reactor_siren[hpos] = siren
+	end
+	if newstate == "danger" and siren.state ~= "danger" then
+		if siren.handle then minetest.sound_stop(siren.handle) end
+		siren.handle = minetest.sound_play("technic_hv_nuclear_reactor_siren_danger_loop", {pos=pos, gain=1.5, loop=true, max_hear_distance=48})
+		siren.state = "danger"
+	elseif newstate == "clear" then
+		if siren.handle then minetest.sound_stop(siren.handle) end
+		local clear_handle = minetest.sound_play("technic_hv_nuclear_reactor_siren_clear", {pos=pos, gain=1.5, loop=false, max_hear_distance=48})
+		siren.handle = clear_handle
+		siren.state = "clear"
+		minetest.after(10, function ()
+			if siren.handle == clear_handle then
+				minetest.sound_stop(clear_handle)
+				if reactor_siren[hpos] == siren then
+					reactor_siren[hpos] = nil
+				end
+			end
+		end)
+	elseif newstate == "off" and siren.state ~= "off" then
+		if siren.handle then minetest.sound_stop(siren.handle) end
+		siren.handle = nil
+		reactor_siren[hpos] = nil
+	end
+end
+local function siren_danger(pos, meta)
+	meta:set_int("siren", 1)
+	siren_set_state(pos, "danger")
+end
+local function siren_clear(pos, meta)
+	if meta:get_int("siren") ~= 0 then
+		siren_set_state(pos, "clear")
+		meta:set_int("siren", 0)
+	end
+end
+
+-- The standard reactor structure consists of a 9x9x9 cube.  A cross
+-- section through the middle:
+--
+--     CCCC CCCC
+--     CBBB BBBC
+--     CBSS SSBC
+--     CBSWWWSBC
+--     CBSW#WSBC
+--     CBSW|WSBC
+--     CBSS|SSBC
+--     CBBB|BBBC
+--     CCCC|CCCC
+--     C = Concrete, B = Blast-resistant concrete, S = Stainless Steel,
+--     W = water node, # = reactor core, | = HV cable
+--
+-- The man-hole and the HV cable are only in the middle, and the man-hole
+-- is optional.
+--
+-- For the reactor to operate and not melt down, it insists on the inner
+-- 7x7x7 portion (from the core out to the blast-resistant concrete)
+-- being intact.  Intactness only depends on the number of nodes of the
+-- right type in each layer.  The water layer must have water in all but
+-- at most one node; the steel and blast-resistant concrete layers must
+-- have the right material in all but at most two nodes.  The permitted
+-- gaps are meant for the cable and man-hole, but can actually be anywhere
+-- and contain anything.  For the reactor to be useful, a cable must
+-- connect to the core, but it can go in any direction.
+--
+-- The outer concrete layer of the standard structure is not required
+-- for the reactor to operate.  It is noted here because it used to
+-- be mandatory, and for historical reasons (that it predates the
+-- implementation of radiation) it needs to continue being adequate
+-- shielding of legacy reactors.  If it ever ceases to be adequate
+-- shielding for new reactors, legacy ones should be grandfathered.
+local reactor_structure_badness = function(pos)
+	local vm = VoxelManip()
+	local pos1 = vector.subtract(pos, 3)
+	local pos2 = vector.add(pos, 3)
+	local MinEdge, MaxEdge = vm:read_from_map(pos1, pos2)
+	local data = vm:get_data()
+	local area = VoxelArea:new({MinEdge=MinEdge, MaxEdge=MaxEdge})
+
+	local c_blast_concrete = minetest.get_content_id("technic:blast_resistant_concrete")
+	local c_stainless_steel = minetest.get_content_id("technic:stainless_steel_block")
+	local c_water_source = minetest.get_content_id("default:water_source")
+	local c_water_flowing = minetest.get_content_id("default:water_flowing")
+
+	local blastlayer, steellayer, waterlayer = 0, 0, 0
+
+	for z = pos1.z, pos2.z do
+	for y = pos1.y, pos2.y do
+	for x = pos1.x, pos2.x do
+		local cid = data[area:index(x, y, z)]
+		if x == pos1.x or x == pos2.x or
+		   y == pos1.y or y == pos2.y or
+		   z == pos1.z or z == pos2.z then
+			if cid == c_blast_concrete then
+				blastlayer = blastlayer + 1
+			end
+		elseif x == pos1.x+1 or x == pos2.x-1 or
+		   y == pos1.y+1 or y == pos2.y-1 or
+		   z == pos1.z+1 or z == pos2.z-1 then
+			if cid == c_stainless_steel then
+				steellayer = steellayer + 1
+			end
+		elseif x == pos1.x+2 or x == pos2.x-2 or
+		   y == pos1.y+2 or y == pos2.y-2 or
+		   z == pos1.z+2 or z == pos2.z-2 then
+			if cid == c_water_source or cid == c_water_flowing then
+				waterlayer = waterlayer + 1
+			end
+		end
+	end
+	end
+	end
+	if waterlayer > 25 then waterlayer = 25 end
+	if steellayer > 96 then steellayer = 96 end
+	if blastlayer > 216 then blastlayer = 216 end
+	return (25 - waterlayer) + (96 - steellayer) + (216 - blastlayer)
+end
+
+local function meltdown_reactor(pos)
+	print("A reactor melted down at "..minetest.pos_to_string(pos))
+	minetest.set_node(pos, {name="technic:corium_source"})
+end
+
+minetest.register_abm({
+	nodenames = {"technic:hv_nuclear_reactor_core_active"},
+	interval = 1,
+	chance = 1,
+	action = function (pos, node)
+		local meta = minetest.get_meta(pos)
+		local badness = reactor_structure_badness(pos)
+		local accum_badness = meta:get_int("structure_accumulated_badness")
+		if badness == 0 then
+			if accum_badness ~= 0 then
+				meta:set_int("structure_accumulated_badness", accum_badness - 1)
+				siren_clear(pos, meta)
+			end
+		else
+			siren_danger(pos, meta)
+			accum_badness = accum_badness + badness
+			if accum_badness >= 100 then
+				meltdown_reactor(pos)
+			else
+				meta:set_int("structure_accumulated_badness", accum_badness)
+			end
+		end
+	end,
+})
+
+local run = function(pos, node)
+	local meta = minetest.get_meta(pos)
+	local machine_name = S("Nuclear %s Generator Core"):format("HV")
+	local burn_time = meta:get_int("burn_time") or 0
+
+	if burn_time >= burn_ticks or burn_time == 0 then
+		local inv = meta:get_inventory()
+		if not inv:is_empty("src") then 
+			local srclist = inv:get_list("src")
+			local correct_fuel_count = 0
+			for _, srcstack in pairs(srclist) do
+				if srcstack then
+					if  srcstack:get_name() == fuel_type then
+						correct_fuel_count = correct_fuel_count + 1
+					end
+				end
+			end
+			-- Check that the reactor is complete as well
+			-- as the correct number of correct fuel
+			if correct_fuel_count == 6 and
+			   reactor_structure_badness(pos) == 0 then
+				meta:set_int("burn_time", 1)
+				technic.swap_node(pos, "technic:hv_nuclear_reactor_core_active") 
+				meta:set_int("HV_EU_supply", power_supply)
+				for idx, srcstack in pairs(srclist) do
+					srcstack:take_item()
+					inv:set_stack("src", idx, srcstack)
+				end
+				return
+			end
+		end
+		meta:set_int("HV_EU_supply", 0)
+		meta:set_int("burn_time", 0)
+		meta:set_string("infotext", S("%s Idle"):format(machine_name))
+		technic.swap_node(pos, "technic:hv_nuclear_reactor_core")
+		meta:set_int("structure_accumulated_badness", 0)
+		siren_clear(pos, meta)
+	elseif burn_time > 0 then
+		burn_time = burn_time + 1
+		meta:set_int("burn_time", burn_time)
+		local percent = math.floor(burn_time / burn_ticks * 100)
+		meta:set_string("infotext", machine_name.." ("..percent.."%)")
+		meta:set_int("HV_EU_supply", power_supply)
+	end
+end
+
+minetest.register_node("technic:hv_nuclear_reactor_core", {
+	description = S("Nuclear %s Generator Core"):format("HV"),
+	tiles = {"technic_hv_nuclear_reactor_core.png", "technic_hv_nuclear_reactor_core.png",
+	         "technic_hv_nuclear_reactor_core.png", "technic_hv_nuclear_reactor_core.png",
+	         "technic_hv_nuclear_reactor_core.png", "technic_hv_nuclear_reactor_core.png"},
+	groups = {cracky=1, technic_machine=1},
+	legacy_facedir_simple = true,
+	sounds = default.node_sound_wood_defaults(),
+	drawtype="nodebox",
+	paramtype = "light",
+	stack_max = 1,
+	node_box = {
+		type = "fixed",
+		fixed = nodebox
+	},
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("Nuclear %s Generator Core"):format("HV"))
+		meta:set_int("HV_EU_supply", 0)
+		-- Signal to the switching station that this device burns some
+		-- sort of fuel and needs special handling
+		meta:set_int("HV_EU_from_fuel", 1)
+		meta:set_int("burn_time", 0)
+		meta:set_string("formspec", generator_formspec)
+		local inv = meta:get_inventory()
+		inv:set_size("src", 6)
+	end,	
+	can_dig = technic.machine_can_dig,
+	on_destruct = function(pos) siren_set_state(pos, "off") end,
+	allow_metadata_inventory_put = technic.machine_inventory_put,
+	allow_metadata_inventory_take = technic.machine_inventory_take,
+	allow_metadata_inventory_move = technic.machine_inventory_move,
+	technic_run = run,
+})
+
+minetest.register_node("technic:hv_nuclear_reactor_core_active", {
+	tiles = {"technic_hv_nuclear_reactor_core.png", "technic_hv_nuclear_reactor_core.png",
+	         "technic_hv_nuclear_reactor_core.png", "technic_hv_nuclear_reactor_core.png",
+		 "technic_hv_nuclear_reactor_core.png", "technic_hv_nuclear_reactor_core.png"},
+	groups = {cracky=1, technic_machine=1, radioactive=11000, not_in_creative_inventory=1},
+	legacy_facedir_simple = true,
+	sounds = default.node_sound_wood_defaults(),
+	drop="technic:hv_nuclear_reactor_core",
+	drawtype="nodebox",
+	light_source = 15,
+	paramtype = "light",
+	node_box = {
+		type = "fixed",
+		fixed = nodebox
+	},
+	can_dig = technic.machine_can_dig,
+	after_dig_node = meltdown_reactor,
+	on_destruct = function(pos) siren_set_state(pos, "off") end,
+	allow_metadata_inventory_put = technic.machine_inventory_put,
+	allow_metadata_inventory_take = technic.machine_inventory_take,
+	allow_metadata_inventory_move = technic.machine_inventory_move,
+	technic_run = run,
+	technic_on_disable = function(pos, node)
+		local timer = minetest.get_node_timer(pos)
+        	timer:start(1)
+        end,
+	on_timer = function(pos, node)
+		local meta = minetest.get_meta(pos)
+		
+		-- Connected back?
+		if meta:get_int("HV_EU_timeout") > 0 then return false end
+		
+		local burn_time = meta:get_int("burn_time") or 0
+
+		if burn_time >= burn_ticks or burn_time == 0 then
+			meta:set_int("HV_EU_supply", 0)
+			meta:set_int("burn_time", 0)
+			technic.swap_node(pos, "technic:hv_nuclear_reactor_core")
+			meta:set_int("structure_accumulated_badness", 0)
+			siren_clear(pos, meta)
+			return false
+		end
+		
+		meta:set_int("burn_time", burn_time + 1)
+		return true
+	end,
+})
+
+technic.register_machine("HV", "technic:hv_nuclear_reactor_core",        technic.producer)
+technic.register_machine("HV", "technic:hv_nuclear_reactor_core_active", technic.producer)
+
+-- radioactivity
+
+-- Radiation resistance represents the extent to which a material
+-- attenuates radiation passing through it; i.e., how good a radiation
+-- shield it is.  This is identified per node type.  For materials that
+-- exist in real life, the radiation resistance value that this system
+-- uses for a node type consisting of a solid cube of that material is the
+-- (approximate) number of halvings of ionising radiation that is achieved
+-- by a metre of the material in real life.  This is approximately
+-- proportional to density, which provides a good way to estimate it.
+-- Homogeneous mixtures of materials have radiation resistance computed
+-- by a simple weighted mean.  Note that the amount of attenuation that
+-- a material achieves in-game is not required to be (and is not) the
+-- same as the attenuation achieved in real life.
+--
+-- Radiation resistance for a node type may be specified in the node
+-- definition, under the key "radiation_resistance".  As an interim
+-- measure, until node definitions widely include this, this code
+-- knows a bunch of values for particular node types in several mods,
+-- and values for groups of node types.  The node definition takes
+-- precedence if it specifies a value.  Nodes for which no value at
+-- all is known are taken to provide no radiation resistance at all;
+-- this is appropriate for the majority of node types.  Only node types
+-- consisting of a fairly homogeneous mass of material should report
+-- non-zero radiation resistance; anything with non-uniform geometry
+-- or complex internal structure should show no radiation resistance.
+-- Fractional resistance values are permitted; two significant figures
+-- is the recommended precision.
+local default_radiation_resistance_per_node = {
+	["default:brick"] = 13,
+	["default:bronzeblock"] = 45,
+	["default:clay"] = 15,
+	["default:coalblock"] = 9.6,
+	["default:cobble"] = 15,
+	["default:copperblock"] = 46,
+	["default:desert_cobble"] = 15,
+	["default:desert_sand"] = 10,
+	["default:desert_stone"] = 17,
+	["default:desert_stonebrick"] = 17,
+	["default:diamondblock"] = 24,
+	["default:dirt"] = 8.2,
+	["default:dirt_with_grass"] = 8.2,
+	["default:dirt_with_grass_footsteps"] = 8.2,
+	["default:dirt_with_snow"] = 8.2,
+	["default:glass"] = 17,
+	["default:goldblock"] = 170,
+	["default:gravel"] = 10,
+	["default:ice"] = 5.6,
+	["default:lava_flowing"] = 8.5,
+	["default:lava_source"] = 17,
+	["default:mese"] = 21,
+	["default:mossycobble"] = 15,
+	["default:nyancat"] = 1000,
+	["default:nyancat_rainbow"] = 1000,
+	["default:obsidian"] = 18,
+	["default:obsidian_glass"] = 18,
+	["default:sand"] = 10,
+	["default:sandstone"] = 15,
+	["default:sandstonebrick"] = 15,
+	["default:snowblock"] = 1.7,
+	["default:steelblock"] = 40,
+	["default:stone"] = 17,
+	["default:stone_with_coal"] = 16,
+	["default:stone_with_copper"] = 20,
+	["default:stone_with_diamond"] = 18,
+	["default:stone_with_gold"] = 34,
+	["default:stone_with_iron"] = 20,
+	["default:stone_with_mese"] = 17,
+	["default:stonebrick"] = 17,
+	["default:water_flowing"] = 2.8,
+	["default:water_source"] = 5.6,
+	["farming:desert_sand_soil"] = 10,
+	["farming:desert_sand_soil_wet"] = 10,
+	["farming:soil"] = 8.2,
+	["farming:soil_wet"] = 8.2,
+	["glooptest:akalin_crystal_glass"] = 21,
+	["glooptest:akalinblock"] = 40,
+	["glooptest:alatro_crystal_glass"] = 21,
+	["glooptest:alatroblock"] = 40,
+	["glooptest:amethystblock"] = 18,
+	["glooptest:arol_crystal_glass"] = 21,
+	["glooptest:crystal_glass"] = 21,
+	["glooptest:emeraldblock"] = 19,
+	["glooptest:heavy_crystal_glass"] = 21,
+	["glooptest:mineral_akalin"] = 20,
+	["glooptest:mineral_alatro"] = 20,
+	["glooptest:mineral_amethyst"] = 17,
+	["glooptest:mineral_arol"] = 20,
+	["glooptest:mineral_desert_coal"] = 16,
+	["glooptest:mineral_desert_iron"] = 20,
+	["glooptest:mineral_emerald"] = 17,
+	["glooptest:mineral_kalite"] = 20,
+	["glooptest:mineral_ruby"] = 18,
+	["glooptest:mineral_sapphire"] = 18,
+	["glooptest:mineral_talinite"] = 20,
+	["glooptest:mineral_topaz"] = 18,
+	["glooptest:reinforced_crystal_glass"] = 21,
+	["glooptest:rubyblock"] = 27,
+	["glooptest:sapphireblock"] = 27,
+	["glooptest:talinite_crystal_glass"] = 21,
+	["glooptest:taliniteblock"] = 40,
+	["glooptest:topazblock"] = 24,
+	["mesecons_extrawires:mese_powered"] = 21,
+	["moreblocks:cactus_brick"] = 13,
+	["moreblocks:cactus_checker"] = 8.5,
+	["moreblocks:circle_stone_bricks"] = 17,
+	["moreblocks:clean_glass"] = 17,
+	["moreblocks:coal_checker"] = 9.0,
+	["moreblocks:coal_glass"] = 17,
+	["moreblocks:coal_stone"] = 17,
+	["moreblocks:coal_stone_bricks"] = 17,
+	["moreblocks:glow_glass"] = 17,
+	["moreblocks:grey_bricks"] = 15,
+	["moreblocks:iron_checker"] = 11,
+	["moreblocks:iron_glass"] = 17,
+	["moreblocks:iron_stone"] = 17,
+	["moreblocks:iron_stone_bricks"] = 17,
+	["moreblocks:plankstone"] = 9.3,
+	["moreblocks:split_stone_tile"] = 15,
+	["moreblocks:split_stone_tile_alt"] = 15,
+	["moreblocks:stone_tile"] = 15,
+	["moreblocks:super_glow_glass"] = 17,
+	["moreblocks:tar"] = 7.0,
+	["moreblocks:wood_tile"] = 1.7,
+	["moreblocks:wood_tile_center"] = 1.7,
+	["moreblocks:wood_tile_down"] = 1.7,
+	["moreblocks:wood_tile_flipped"] = 1.7,
+	["moreblocks:wood_tile_full"] = 1.7,
+	["moreblocks:wood_tile_left"] = 1.7,
+	["moreblocks:wood_tile_right"] = 1.7,
+	["moreblocks:wood_tile_up"] = 1.7,
+	["moreores:mineral_mithril"] = 18,
+	["moreores:mineral_silver"] = 21,
+	["moreores:mineral_tin"] = 19,
+	["moreores:mithril_block"] = 26,
+	["moreores:silver_block"] = 53,
+	["moreores:tin_block"] = 37,
+	["snow:snow_brick"] = 2.8,
+	["technic:brass_block"] = 43,
+	["technic:carbon_steel_block"] = 40,
+	["technic:cast_iron_block"] = 40,
+	["technic:chernobylite_block"] = 40,
+	["technic:chromium_block"] = 37,
+	["technic:corium_flowing"] = 40,
+	["technic:corium_source"] = 80,
+	["technic:granite"] = 18,
+	["technic:lead_block"] = 80,
+	["technic:marble"] = 18,
+	["technic:marble_bricks"] = 18,
+	["technic:mineral_chromium"] = 19,
+	["technic:mineral_uranium"] = 71,
+	["technic:mineral_zinc"] = 19,
+	["technic:stainless_steel_block"] = 40,
+	["technic:zinc_block"] = 36,
+	["tnt:tnt"] = 11,
+	["tnt:tnt_burning"] = 11,
+}
+local default_radiation_resistance_per_group = {
+	concrete = 16,
+	tree = 3.4,
+	uranium_block = 500,
+	wood = 1.7,
+}
+local cache_radiation_resistance = {}
+local function node_radiation_resistance(nodename)
+	local eff = cache_radiation_resistance[nodename]
+	if eff then return eff end
+	local def = minetest.registered_nodes[nodename] or {groups={}}
+	eff = def.radiation_resistance or default_radiation_resistance_per_node[nodename]
+	if not eff then
+		for g, v in pairs(def.groups) do
+			if v > 0 and default_radiation_resistance_per_group[g] then
+				eff = default_radiation_resistance_per_group[g]
+				break
+			end
+		end
+	end
+	if not eff then eff = 0 end
+	cache_radiation_resistance[nodename] = eff
+	return eff
+end
+
+-- Radioactive nodes cause damage to nearby players.  The damage
+-- effect depends on the intrinsic strength of the radiation source,
+-- the distance between the source and the player, and the shielding
+-- effect of the intervening material.  These determine a rate of damage;
+-- total damage caused is the integral of this over time.
+--
+-- In the absence of effective shielding, for a specific source the
+-- damage rate varies realistically in inverse proportion to the square
+-- of the distance.  (Distance is measured to the player's abdomen,
+-- not to the nominal player position which corresponds to the foot.)
+-- However, if the player is inside a non-walkable (liquid or gaseous)
+-- radioactive node, the nominal distance could go to zero, yielding
+-- infinite damage.  In that case, the player's body is displacing the
+-- radioactive material, so the effective distance should remain non-zero.
+-- We therefore apply a lower distance bound of sqrt(0.75) m, which is
+-- the maximum distance one can get from the node centre within the node.
+--
+-- A radioactive node is identified by being in the "radioactive" group,
+-- and the group value signifies the strength of the radiation source.
+-- The group value is the distance in millimetres from a node at which
+-- an unshielded player will be damaged by 0.25 HP/s.  Or, equivalently,
+-- it is 2000 times the square root of the damage rate in HP/s that an
+-- unshielded player 1 m away will take.
+--
+-- Shielding is assessed by sampling every 0.25 m along the path
+-- from the source to the player, ignoring the source node itself.
+-- The summed shielding values from the sampled nodes yield a measure
+-- of the total amount of shielding on the path.  As in reality,
+-- shielding causes exponential attenuation of radiation.  However, the
+-- effect is scaled down relative to real life.  A metre of a node with
+-- radiation resistance value R yields attenuation of sqrt(R)*0.1 nepers.
+-- (In real life it would be about R*0.69 nepers, by the definition
+-- of the radiation resistance values.)  The sqrt part of this formula
+-- scales down the differences between shielding types, reflecting the
+-- game's simplification of making expensive materials such as gold
+-- readily available in cubic metres.  The multiplicative factor in the
+-- formula scales down the difference between shielded and unshielded
+-- safe distances, avoiding the latter becoming impractically large.
+--
+-- Damage is processed at rates down to 0.25 HP/s, which in the absence of
+-- shielding is attained at the distance specified by the "radioactive"
+-- group value.  Computed damage rates below 0.25 HP/s result in no
+-- damage at all to the player.  This gives the player an opportunity
+-- to be safe, and limits the range at which source/player interactions
+-- need to be considered.
+local assumed_abdomen_offset = vector.new(0, 1, 0)
+local assumed_abdomen_offset_length = vector.length(assumed_abdomen_offset)
+local cache_scaled_shielding = {}
+
+local damage_enabled = minetest.setting_getbool("enable_damage")
+
+if damage_enabled then
+	minetest.register_abm({
+		nodenames = {"group:radioactive"},
+		interval = 1,
+		chance = 1,
+		action = function (pos, node)
+			local strength = minetest.registered_nodes[node.name].groups.radioactive
+			for _, o in ipairs(minetest.get_objects_inside_radius(pos, strength*0.001 + assumed_abdomen_offset_length)) do
+				if o:is_player() then
+					local rel = vector.subtract(vector.add(o:getpos(), assumed_abdomen_offset), pos)
+					local dist_sq = vector.length_square(rel)
+					local dist = math.sqrt(dist_sq)
+					local dirstep = dist == 0 and vector.new(0,0,0) or vector.divide(rel, dist*4)
+					local intpos = pos
+					local shielding = 0
+					for intdist = 0.25, dist, 0.25 do
+						intpos = vector.add(intpos, dirstep)
+						local intnodepos = vector.round(intpos)
+						if not vector.equals(intnodepos, pos) then
+							local sname = minetest.get_node(intnodepos).name
+							local sval = cache_scaled_shielding[sname]
+							if not sval then
+								sval = math.sqrt(node_radiation_resistance(sname)) * -0.025
+								cache_scaled_shielding[sname] = sval
+							end
+							shielding = shielding + sval
+						end
+					end
+					local dmg_rate = 0.25e-6 * strength*strength * math.exp(shielding) / math.max(0.75, dist_sq)
+					if dmg_rate >= 0.25 then
+						local dmg_int = math.floor(dmg_rate)
+						if math.random() < dmg_rate-dmg_int then
+							dmg_int = dmg_int + 1
+						end
+						if dmg_int > 0 then
+							o:set_hp(math.max(o:get_hp() - dmg_int, 0))
+						end
+					end
+				end
+			end
+		end,
+	})
+end
+
+-- radioactive materials that can result from destroying a reactor
+local corium_griefing = 1 
+if (not technic.config:get_bool("enable_corium_griefing")) then
+	corium_griefing = 0
+end
+
+for _, state in ipairs({ "flowing", "source" }) do
+	minetest.register_node("technic:corium_"..state, {
+		description = S(state == "source" and "Corium Source" or "Flowing Corium"),
+		drawtype = (state == "source" and "liquid" or "flowingliquid"),
+		[state == "source" and "tiles" or "special_tiles"] = {{
+			name = "technic_corium_"..state.."_animated.png",
+			animation = {
+				type = "vertical_frames",
+				aspect_w = 16,
+				aspect_h = 16,
+				length = 3.0,
+			},
+		}},
+		paramtype = "light",
+		paramtype2 = (state == "flowing" and "flowingliquid" or nil),
+		light_source = (state == "source" and 8 or 5),
+		walkable = false,
+		pointable = false,
+		diggable = false,
+		buildable_to = true,
+		drop = "",
+		drowning = 1,
+		liquidtype = state,
+		liquid_alternative_flowing = "technic:corium_flowing",
+		liquid_alternative_source = "technic:corium_source",
+		liquid_viscosity = LAVA_VISC,
+		liquid_renewable = false,
+		damage_per_second = 6,
+		post_effect_color = { a=192, r=80, g=160, b=80 },
+		groups = {
+			liquid = 2,
+			hot = 3,
+			igniter = corium_griefing,
+			radioactive = (state == "source" and 32000 or 16000),
+			not_in_creative_inventory = (state == "flowing" and 1 or nil),
+		},
+	})
+end
+
+if bucket and bucket.register_liquid then
+	bucket.register_liquid(
+		"technic:corium_source",
+		"technic:corium_flowing",
+		"technic:bucket_corium",
+		"technic_bucket_corium.png",
+		"Corium Bucket"
+	)
+end
+
+minetest.register_node("technic:chernobylite_block", {
+        description = S("Chernobylite Block"),
+	tiles = { "technic_chernobylite_block.png" },
+	is_ground_content = true,
+	groups = { cracky=1, radioactive=5000, level=2 },
+	sounds = default.node_sound_stone_defaults(),
+	light_source = 2,
+
+})
+
+minetest.register_abm({
+	nodenames = {"group:water"},
+	neighbors = {"technic:corium_source"},
+	interval = 1,
+	chance = 1,
+	action = function (pos, node)
+		minetest.remove_node(pos)
+	end,
+})
+
+if (corium_griefing == 1) then
+	minetest.register_abm({
+		nodenames = {"technic:corium_flowing"},
+		interval = 5,
+		chance = 10,
+		action = function (pos, node)
+			minetest.set_node(pos, {name="technic:chernobylite_block"})
+		end,
+	})
+	minetest.register_abm({
+		nodenames = { "technic:corium_source", "technic:corium_flowing" },
+		interval = 4,
+		chance = 4,
+		action = function (pos, node)
+			for _, offset in ipairs({
+				vector.new(1,0,0),
+				vector.new(-1,0,0),
+				vector.new(0,0,1),
+				vector.new(0,0,-1),
+				vector.new(0,-1,0),
+			}) do
+				if math.random(8) == 1 then
+					minetest.dig_node(vector.add(pos, offset))
+				end
+			end
+		end,
+	})
+end
diff --git a/technic/machines/HV/quarry.lua b/technic/machines/HV/quarry.lua
new file mode 100644
index 0000000..60805cc
--- /dev/null
+++ b/technic/machines/HV/quarry.lua
@@ -0,0 +1,251 @@
+
+local S = technic.getter
+
+minetest.register_craft({
+	recipe = {
+		{"technic:carbon_plate",       "pipeworks:filter",       "technic:composite_plate"},
+		{"technic:motor",              "technic:machine_casing", "technic:diamond_drill_head"},
+		{"technic:carbon_steel_block", "technic:hv_cable0",      "technic:carbon_steel_block"}},
+	output = "technic:quarry",
+})
+
+local quarry_dig_above_nodes = 3 -- How far above the quarry we will dig nodes
+local quarry_max_depth       = 100
+local quarry_demand = 10000
+
+local function set_quarry_formspec(meta)
+	local radius = meta:get_int("size")
+	local formspec = "size[6,4.3]"..
+		"list[context;cache;0,1;4,3;]"..
+		"item_image[4.8,0;1,1;technic:quarry]"..
+		"label[0,0.2;"..S("%s Quarry"):format("HV").."]"..
+		"field[4.3,3.5;2,1;size;"..S("Radius:")..";"..radius.."]"
+	if meta:get_int("enabled") == 0 then
+		formspec = formspec.."button[4,1;2,1;enable;"..S("Disabled").."]"
+	else
+		formspec = formspec.."button[4,1;2,1;disable;"..S("Enabled").."]"
+	end
+	local diameter = radius*2 + 1
+	local nd = meta:get_int("dug")
+	local rel_y = quarry_dig_above_nodes - math.floor(nd / (diameter*diameter))
+	formspec = formspec.."label[0,4;"..minetest.formspec_escape(
+			nd == 0 and S("Digging not started") or
+			(rel_y < -quarry_max_depth and S("Digging finished") or
+				(meta:get_int("purge_on") == 1 and S("Purging cache") or
+				S("Digging %d m "..(rel_y > 0 and "above" or "below").." machine")
+					:format(math.abs(rel_y))))
+			).."]"
+	formspec = formspec.."button[4,2;2,1;restart;"..S("Restart").."]"
+	meta:set_string("formspec", formspec)
+end
+
+local function set_quarry_demand(meta)
+	local radius = meta:get_int("size")
+	local diameter = radius*2 + 1
+	local machine_name = S("%s Quarry"):format("HV")
+	if meta:get_int("enabled") == 0 or meta:get_int("purge_on") == 1 then
+		meta:set_string("infotext", S(meta:get_int("purge_on") == 1 and "%s purging cache" or "%s Disabled"):format(machine_name))
+		meta:set_int("HV_EU_demand", 0)
+	elseif meta:get_int("dug") == diameter*diameter * (quarry_dig_above_nodes+1+quarry_max_depth) then
+		meta:set_string("infotext", S("%s Finished"):format(machine_name))
+		meta:set_int("HV_EU_demand", 0)
+	else
+		meta:set_string("infotext", S(meta:get_int("HV_EU_input") >= quarry_demand and "%s Active" or "%s Unpowered"):format(machine_name))
+		meta:set_int("HV_EU_demand", quarry_demand)
+	end
+end
+
+local function quarry_receive_fields(pos, formname, fields, sender)
+	local meta = minetest.get_meta(pos)
+	if fields.size and string.find(fields.size, "^[0-9]+$") then
+		local size = tonumber(fields.size)
+		if size >= 2 and size <= 8 and size ~= meta:get_int("size") then
+			meta:set_int("size", size)
+			meta:set_int("dug", 0)
+		end
+	end
+	if fields.enable then meta:set_int("enabled", 1) end
+	if fields.disable then meta:set_int("enabled", 0) end
+	if fields.restart then
+		meta:set_int("dug", 0)
+		meta:set_int("purge_on", 1)
+	end
+	set_quarry_formspec(meta)
+	set_quarry_demand(meta)
+end
+
+local function quarry_handle_purge(pos)
+	local meta = minetest.get_meta(pos)
+	local inv = meta:get_inventory()
+	local i = 0
+	for _,stack in ipairs(inv:get_list("cache")) do
+		i = i + 1
+		if stack then
+			local item = stack:to_table()
+			if item then
+				technic.tube_inject_item(pos, pos, vector.new(0, 1, 0), item)
+				stack:clear()
+				inv:set_stack("cache", i, stack)
+				break
+			end
+		end
+	end
+	if inv:is_empty("cache") then
+		meta:set_int("purge_on", 0)
+	end
+end
+
+local function quarry_run(pos, node)
+	local meta = minetest.get_meta(pos)
+	local inv = meta:get_inventory()
+	-- initialize cache for the case we load an older world
+	inv:set_size("cache", 12)
+	-- toss a coin whether we do an automatic purge. Chance 1:200
+	local purge_rand = math.random()
+	if purge_rand <= 0.005 then
+		meta:set_int("purge_on", 1)
+	end
+
+	if meta:get_int("enabled") and meta:get_int("HV_EU_input") >= quarry_demand and meta:get_int("purge_on") == 0 then
+		local pdir = minetest.facedir_to_dir(node.param2)
+		local qdir = pdir.x == 1 and vector.new(0,0,-1) or
+			(pdir.z == -1 and vector.new(-1,0,0) or
+			(pdir.x == -1 and vector.new(0,0,1) or
+			vector.new(1,0,0)))
+		local radius = meta:get_int("size")
+		local diameter = radius*2 + 1
+		local startpos = vector.add(vector.add(vector.add(pos,
+			vector.new(0, quarry_dig_above_nodes, 0)),
+			pdir),
+			vector.multiply(qdir, -radius))
+		local endpos = vector.add(vector.add(vector.add(startpos,
+			vector.new(0, -quarry_dig_above_nodes-quarry_max_depth, 0)),
+			vector.multiply(pdir, diameter-1)),
+			vector.multiply(qdir, diameter-1))
+		local vm = VoxelManip()
+		local minpos, maxpos = vm:read_from_map(startpos, endpos)
+		local area = VoxelArea:new({MinEdge=minpos, MaxEdge=maxpos})
+		local data = vm:get_data()
+		local c_air = minetest.get_content_id("air")
+		local owner = meta:get_string("owner")
+		local nd = meta:get_int("dug")
+		while nd ~= diameter*diameter * (quarry_dig_above_nodes+1+quarry_max_depth) do
+			local ry = math.floor(nd / (diameter*diameter))
+			local ndl = nd % (diameter*diameter)
+			if ry % 2 == 1 then
+				ndl = diameter*diameter - 1 - ndl
+			end
+			local rq = math.floor(ndl / diameter)
+			local rp = ndl % diameter
+			if rq % 2 == 1 then rp = diameter - 1 - rp end
+			local digpos = vector.add(vector.add(vector.add(startpos,
+				vector.new(0, -ry, 0)),
+				vector.multiply(pdir, rp)),
+				vector.multiply(qdir, rq))
+			local can_dig = true
+			if can_dig and minetest.is_protected and minetest.is_protected(digpos, owner) then
+				can_dig = false
+			end
+			local dignode
+			if can_dig then
+				dignode = technic.get_or_load_node(digpos) or minetest.get_node(digpos)
+				local dignodedef = minetest.registered_nodes[dignode.name] or {diggable=false}
+				if not dignodedef.diggable or (dignodedef.can_dig and not dignodedef.can_dig(digpos, nil)) then
+					can_dig = false
+				end
+			end
+
+			if can_dig then
+				for ay = startpos.y, digpos.y+1, -1 do
+					local checkpos = {x=digpos.x, y=ay, z=digpos.z}
+					local checknode = technic.get_or_load_node(checkpos) or minetest.get_node(checkpos)
+					if checknode.name ~= "air" then
+						can_dig = false
+						break
+					end
+				end
+			end
+			nd = nd + 1
+			if can_dig then
+				minetest.remove_node(digpos)
+				local drops = minetest.get_node_drops(dignode.name, "")
+				for _, dropped_item in ipairs(drops) do
+					local left = inv:add_item("cache", dropped_item)
+					while not left:is_empty() do
+						meta:set_int("purge_on", 1)
+						quarry_handle_purge(pos)
+						left = inv:add_item("cache", left)
+					end
+				end
+				break
+			end
+		end
+		if nd == diameter*diameter * (quarry_dig_above_nodes+1+quarry_max_depth) then
+			-- if a quarry is finished, we enable purge mode
+			meta:set_int("purge_on", 1)
+		end
+		meta:set_int("dug", nd)
+	else
+		-- if a quarry is disabled or has no power, we enable purge mode
+		meta:set_int("purge_on", 1)
+	end
+	-- if something triggered a purge, we handle it
+	if meta:get_int("purge_on") == 1 then
+		quarry_handle_purge(pos)
+	end
+	set_quarry_formspec(meta)
+	set_quarry_demand(meta)
+end
+
+local function send_move_error(player)
+	minetest.chat_send_player(player:get_player_name(),
+		S("Manually taking/removing from cache by hand is not possible. "..
+		"If you can't wait, restart or disable the quarry to start automatic purge."))
+	return 0
+end
+
+minetest.register_node("technic:quarry", {
+	description = S("%s Quarry"):format("HV"),
+	tiles = {"technic_carbon_steel_block.png", "technic_carbon_steel_block.png",
+	         "technic_carbon_steel_block.png", "technic_carbon_steel_block.png",
+	         "technic_carbon_steel_block.png^default_tool_mesepick.png", "technic_carbon_steel_block.png"},
+	inventory_image = minetest.inventorycube("technic_carbon_steel_block.png",
+	         "technic_carbon_steel_block.png^default_tool_mesepick.png",
+	         "technic_carbon_steel_block.png"),
+	paramtype2 = "facedir",
+	groups = {cracky=2, tubedevice=1, technic_machine = 1},
+	tube = {
+		connect_sides = {top = 1},
+	},
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("%s Quarry"):format("HV"))
+		meta:set_int("size", 4)
+		set_quarry_formspec(meta)
+		set_quarry_demand(meta)
+	end,
+	after_place_node = function(pos, placer, itemstack)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("owner", placer:get_player_name())
+		pipeworks.scan_for_tube_objects(pos)
+	end,
+	can_dig = function(pos,player)
+		local meta = minetest.get_meta(pos);
+		local inv = meta:get_inventory()
+		return inv:is_empty("cache")
+	end,
+	after_dig_node = pipeworks.scan_for_tube_objects,
+	on_receive_fields = quarry_receive_fields,
+	technic_run = quarry_run,
+	allow_metadata_inventory_move = function(pos, from_list, from_index, to_list, to_index, count, player)
+		return send_move_error(player)
+	end,
+	allow_metadata_inventory_put = function(pos, listname, index, stack, player)
+		return send_move_error(player)
+	end,
+	allow_metadata_inventory_take = function(pos, listname, index, stack, player)
+		return send_move_error(player)
+	end
+})
+
+technic.register_machine("HV", "technic:quarry", technic.receiver)
diff --git a/technic/machines/HV/solar_array.lua b/technic/machines/HV/solar_array.lua
new file mode 100644
index 0000000..414291a
--- /dev/null
+++ b/technic/machines/HV/solar_array.lua
@@ -0,0 +1,14 @@
+-- The high voltage solar array is an assembly of medium voltage arrays.
+-- Solar arrays are not able to store large amounts of energy.
+
+minetest.register_craft({
+	output = 'technic:solar_array_hv 1',
+	recipe = {
+		{'technic:solar_array_mv',     'technic:solar_array_mv', 'technic:solar_array_mv'},
+		{'technic:carbon_plate',       'technic:hv_transformer', 'technic:composite_plate'},
+		{'',                           'technic:hv_cable0',      ''},
+	}
+})
+
+technic.register_solar_array({tier="HV", power=100})
+