many worldgen mods and gonna try technic now

mods/technic_plus/technic/machines/HV/battery_box.lua

@@ -0,0 +1,22 @@
+-- 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_cable',        ''},
+	}
+})
+
+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,
+})
+

mods/technic_plus/technic/machines/HV/cables.lua

@@ -0,0 +1,47 @@
+minetest.register_craft({
+	output = 'technic:hv_cable 3',
+	recipe = {
+		{'homedecor:plastic_sheeting', 'homedecor:plastic_sheeting', 'homedecor:plastic_sheeting'},
+		{'technic:mv_cable',           'technic:mv_cable',           'technic:mv_cable'},
+		{'homedecor:plastic_sheeting', 'homedecor:plastic_sheeting', 'homedecor:plastic_sheeting'},
+	}
+})
+
+technic.register_cable("HV", 3/16)
+
+if minetest.get_modpath("digilines") then
+
+	local S = technic.getter
+
+	if minetest.get_modpath("digistuff") then
+		minetest.register_craft({
+			output = 'technic:hv_digi_cable 1',
+			type = "shapeless",
+			recipe = {'digistuff:digimese', 'technic:hv_cable'}
+		})
+	else
+		minetest.register_craft({
+			output = 'technic:hv_digi_cable 1',
+			recipe = {
+				{'digilines:wire_std_00000000', 'digilines:wire_std_00000000', 'digilines:wire_std_00000000'},
+				{'digilines:wire_std_00000000', 'technic:hv_cable',            'digilines:wire_std_00000000'},
+				{'digilines:wire_std_00000000', 'digilines:wire_std_00000000', 'digilines:wire_std_00000000'},
+			}
+		})
+	end
+
+	technic.register_cable("HV", 3/16, S("HV Cable (digiline)"), "_digi", {
+		digiline = {
+			wire = {
+				rules = {
+					{x = 1, y = 0, z = 0},
+					{x =-1, y = 0, z = 0},
+					{x = 0, y = 1, z = 0},
+					{x = 0, y =-1, z = 0},
+					{x = 0, y = 0, z = 1},
+					{x = 0, y = 0, z =-1}
+				}
+			}
+		}
+	})
+end

mods/technic_plus/technic/machines/HV/compressor.lua

@@ -0,0 +1,12 @@
+-- HV compressor
+
+minetest.register_craft({
+	output = 'technic:hv_compressor',
+	recipe = {
+		{'technic:carbon_plate',          'technic:mv_compressor',   'technic:composite_plate'},
+		{'pipeworks:tube_1',              'technic:hv_transformer', 'pipeworks:tube_1'},
+		{'technic:stainless_steel_ingot', 'technic:hv_cable',       'technic:stainless_steel_ingot'},
+	}
+})
+
+technic.register_compressor({tier = "HV", demand = {1500, 1000, 750}, speed = 5, upgrade = 1, tube = 1})

mods/technic_plus/technic/machines/HV/electric_furnace.lua

@@ -0,0 +1,18 @@
+-- MV Electric Furnace
+-- This is a faster version of the stone furnace which runs on EUs
+-- In addition to this it can be upgraded with microcontrollers and batteries
+-- This new version uses the batteries to lower the power consumption of the machine
+-- Also in addition this furnace can be attached to the pipe system from the pipeworks mod.
+
+-- FIXME: kpoppel I'd like to introduce an induction heating element here also
+minetest.register_craft({
+	output = 'technic:hv_electric_furnace',
+	recipe = {
+		{'technic:stainless_steel_ingot', 'technic:mv_electric_furnace', 'technic:stainless_steel_ingot'},
+		{'pipeworks:tube_1',              'technic:hv_transformer',      'pipeworks:tube_1'},
+		{'technic:stainless_steel_ingot', 'technic:hv_cable',            'technic:stainless_steel_ingot'},
+	}
+})
+
+technic.register_electric_furnace({tier="HV", upgrade=1, tube=1, demand={4000, 2500, 1500}, speed=12})
+

mods/technic_plus/technic/machines/HV/forcefield.lua

@@ -0,0 +1,390 @@
+--- 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 digilines_path = minetest.get_modpath("digilines")
+
+local forcefield_power_drain   = 10
+
+local S = technic.getter
+
+local cable_entry = "^technic_cable_connection_overlay.png"
+
+minetest.register_craft({
+	output = "technic:forcefield_emitter_off",
+	recipe = {
+		{"default:mese",         "basic_materials:motor",          "default:mese"        },
+		{"technic:deployer_off", "technic:machine_casing", "technic:deployer_off"},
+		{"default:mese",         "technic:hv_cable",       "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)
+
+	if active then
+		-- rate limit by chance
+		if math.floor(math.random()*4) ~= 0 then
+			return
+		end
+	end
+
+	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()
+end
+
+local function set_forcefield_formspec(meta)
+	local formspec
+	if digilines_path then
+		formspec = "size[5,3.25]"..
+			"field[0.3,3;5,1;channel;Digiline Channel;"..meta:get_string("channel").."]"
+	else
+		formspec = "size[5,2.25]"
+	end
+	formspec = formspec..
+		"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 player_name = sender:get_player_name()
+	if minetest.is_protected(pos, player_name) then
+		minetest.chat_send_player(player_name, "You are not allowed to edit this!")
+		minetest.record_protection_violation(pos, player_name)
+		return
+	end
+	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.channel then meta:set_string("channel", fields.channel) 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 digiline_def = {
+	receptor = {
+		rules = technic.digilines.rules,
+		action = function() end
+	},
+	effector = {
+		rules = technic.digilines.rules,
+		action = function(pos, node, channel, msg)
+			local meta = minetest.get_meta(pos)
+			if channel ~= meta:get_string("channel") then
+				return
+			end
+			local msgt = type(msg)
+			if msgt == "string" then
+				local smsg = msg:lower()
+				msg = {}
+				if smsg == "get" then
+					msg.command = "get"
+				elseif smsg == "off" then
+					msg.command = "off"
+				elseif smsg == "on" then
+					msg.command = "on"
+				elseif smsg == "toggle" then
+					msg.command = "toggle"
+				elseif smsg:sub(1, 5) == "range" then
+					msg.command = "range"
+					msg.value = tonumber(smsg:sub(7))
+				elseif smsg:sub(1, 5) == "shape" then
+					msg.command = "shape"
+					msg.value = smsg:sub(7):lower()
+					msg.value = tonumber(msg.value) or msg.value
+				end
+			elseif msgt ~= "table" then
+				return
+			end
+			if msg.command == "get" then
+				digilines.receptor_send(pos, technic.digilines.rules, channel, {
+					enabled = meta:get_int("enabled"),
+					range   = meta:get_int("range"),
+					shape   = meta:get_int("shape")
+				})
+				return
+			elseif msg.command == "off" then
+				meta:set_int("enabled", 0)
+			elseif msg.command == "on" then
+				meta:set_int("enabled", 1)
+			elseif msg.command == "toggle" then
+				local onn = meta:get_int("enabled")
+				onn = 1-onn -- Mirror onn with pivot 0.5, so switch between 1 and 0.
+				meta:set_int("enabled", onn)
+			elseif msg.command == "range" then
+				if type(msg.value) ~= "number" then
+					return
+				end
+				msg.value = math.max(msg.value, 5)
+				msg.value = math.min(msg.value, 20)
+				update_forcefield(pos, meta, false)
+				meta:set_int("range", msg.value)
+			elseif msg.command == "shape" then
+				local valuet = type(msg.value)
+				if valuet == "string" then
+					if msg.value == "sphere" then
+						msg.value = 0
+					elseif msg.value == "cube" then
+						msg.value = 1
+					end
+				elseif valuet ~= "number" then
+					return
+				end
+				if not msg.value then
+					return
+				end
+				update_forcefield(pos, meta, false)
+				meta:set_int("shape", msg.value)
+			else
+				return
+			end
+			set_forcefield_formspec(meta)
+		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
+		if node.name == "technic:forcefield_emitter_off" then
+			technic.swap_node(pos, "technic:forcefield_emitter_on")
+			meta:set_string("infotext", S("%s Active"):format(machine_name))
+		end
+		update_forcefield(pos, meta, true)
+	end
+end
+
+minetest.register_node("technic:forcefield_emitter_off", {
+	description = S("%s Forcefield Emitter"):format("HV"),
+	tiles = {
+		"technic_forcefield_emitter_off.png",
+		"technic_machine_bottom.png"..cable_entry,
+		"technic_forcefield_emitter_off.png",
+		"technic_forcefield_emitter_off.png",
+		"technic_forcefield_emitter_off.png",
+		"technic_forcefield_emitter_off.png"
+	},
+	groups = {cracky = 1, technic_machine = 1, technic_hv = 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)
+		if digilines_path then
+			meta:set_string("channel", "forcefield"..minetest.pos_to_string(pos))
+		end
+		meta:set_string("infotext", S("%s Forcefield Emitter"):format("HV"))
+		set_forcefield_formspec(meta)
+	end,
+	mesecons = mesecons,
+	digiline = digiline_def,
+	technic_run = run,
+})
+
+minetest.register_node("technic:forcefield_emitter_on", {
+	description = S("%s Forcefield Emitter"):format("HV"),
+	tiles = {
+		"technic_forcefield_emitter_on.png",
+		"technic_machine_bottom.png"..cable_entry,
+		"technic_forcefield_emitter_on.png",
+		"technic_forcefield_emitter_on.png",
+		"technic_forcefield_emitter_on.png",
+		"technic_forcefield_emitter_on.png"
+	},
+	groups = {cracky = 1, technic_machine = 1, technic_hv = 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,
+	digiline = digiline_def,
+	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,
+	on_blast = function(pos, intensity)
+		minetest.dig_node(pos)
+		return {"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 = default.LIGHT_MAX,
+	diggable = false,
+	drop = '',
+	tiles = {{
+		name = "technic_forcefield_animated.png",
+		animation = {
+			type = "vertical_frames",
+			aspect_w = 16,
+			aspect_h = 16,
+			length = 1.0,
+		},
+	}},
+	on_blast = function(pos, intensity)
+	end,
+})
+
+
+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)

mods/technic_plus/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_cable',       'technic:stainless_steel_ingot'},
+	}
+})
+
+technic.register_generator({tier="HV", tube=1, supply=1200})
+

mods/technic_plus/technic/machines/HV/grinder.lua

@@ -0,0 +1,13 @@
+-- HV grinder
+
+minetest.register_craft({
+	output = 'technic:hv_grinder',
+	recipe = {
+		{'technic:carbon_plate',          'technic:mv_grinder',   'technic:composite_plate'},
+		{'pipeworks:tube_1',              'technic:hv_transformer', 'pipeworks:tube_1'},
+		{'technic:stainless_steel_ingot', 'technic:hv_cable',       'technic:stainless_steel_ingot'},
+	}
+})
+
+technic.register_grinder({tier="HV", demand={1200, 900, 600}, speed=5, upgrade=1, tube=1})
+

mods/technic_plus/technic/machines/HV/init.lua

@@ -0,0 +1,22 @@
+
+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")
+dofile(path.."/electric_furnace.lua")
+dofile(path.."/grinder.lua")
+dofile(path.."/compressor.lua")
+
+

mods/technic_plus/technic/machines/HV/nuclear_reactor.lua

@@ -0,0 +1,514 @@
+--[[
+ 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.
+Provides 10000 HV EUs for one week (only counted when loaded).
+
+The nuclear reactor core requires a casing of water and a protective
+shield to work.  This is checked now and then and if the casing is not
+intact the reactor will melt down!
+--]]
+
+local burn_ticks = 7 * 24 * 60 * 60  -- Seconds
+local power_supply = 100000  -- EUs
+local fuel_type = "technic:uranium_fuel"  -- The reactor burns this
+local digiline_meltdown = technic.config:get_bool("enable_nuclear_reactor_digiline_selfdestruct")
+local has_digilines = minetest.get_modpath("digilines")
+
+local S = technic.getter
+
+local reactor_desc = S("@1 Nuclear Reactor Core", S("HV"))
+local cable_entry = "^technic_cable_connection_overlay.png"
+
+-- FIXME: Recipe should 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_cable',       'technic:stainless_steel_ingot'},
+	}
+})
+
+local function make_reactor_formspec(meta)
+	local f = "size[8,9]"..
+	"label[0,0;"..S("Nuclear Reactor Rod Compartment").."]"..
+	"list[context;src;2,1;3,2;]"..
+	"list[current_player;main;0,5;8,4;]"..
+	"listring[]"..
+	"button[5.5,1.5;2,1;start;Start]"..
+	"checkbox[5.5,2.5;autostart;automatic Start;"..meta:get_string("autostart").."]"
+	if not has_digilines then
+		return f
+	end
+	local digiline_enabled = meta:get_string("enable_digiline")
+	f = f.."checkbox[0.5,2.8;enable_digiline;Enable Digiline;"..digiline_enabled.."]"
+	if digiline_enabled ~= "true" then
+		return f
+	end
+	return f..
+		"button_exit[4.6,3.69;2,1;save;Save]"..
+		"field[1,4;4,1;remote_channel;Digiline Remote Channel;${remote_channel}]"
+end
+
+local SS_OFF = 0
+local SS_DANGER = 1
+local SS_CLEAR = 2
+
+local reactor_siren = {}
+local function siren_set_state(pos, state)
+	local hpos = minetest.hash_node_position(pos)
+	local siren = reactor_siren[hpos]
+	if not siren then
+		if state == SS_OFF then return end
+		siren = {state=SS_OFF}
+		reactor_siren[hpos] = siren
+	end
+	if state == SS_DANGER and siren.state ~= SS_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 = SS_DANGER
+	elseif state == SS_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 = SS_CLEAR
+		minetest.after(10, function()
+			if siren.handle ~= clear_handle then return end
+			minetest.sound_stop(clear_handle)
+			if reactor_siren[hpos] == siren then
+				reactor_siren[hpos] = nil
+			end
+		end)
+	elseif state == SS_OFF and siren.state ~= SS_OFF then
+		if siren.handle then minetest.sound_stop(siren.handle) end
+		reactor_siren[hpos] = nil
+	end
+end
+
+local function siren_danger(pos, meta)
+	meta:set_int("siren", 1)
+	siren_set_state(pos, SS_DANGER)
+end
+
+local function siren_clear(pos, meta)
+	if meta:get_int("siren") ~= 0 then
+		siren_set_state(pos, SS_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
+	CBLL LLBC
+	CBLWWWLBC
+	CBLW#WLBC
+	CBLW|WLBC
+	CBLL|LLBC
+	CBBB|BBBC
+	CCCC|CCCC
+	C = Concrete, B = Blast-resistant concrete, L = Lead,
+	W = water node, # = reactor core, | = HV cable
+
+The man-hole is optional (but necessary for refueling).
+
+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.
+
+For legacy reasons, if the reactor has a stainless steel layer instead
+of a lead layer it will be converted to a lead layer.
+--]]
+local function reactor_structure_badness(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_lead = minetest.get_content_id("technic:lead_block")
+	local c_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 blast_layer, steel_layer, lead_layer, water_layer = 0, 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
+				blast_layer = blast_layer + 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_lead then
+				lead_layer = lead_layer + 1
+			elseif cid == c_steel then
+				steel_layer = steel_layer + 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
+				water_layer = water_layer + 1
+			end
+		end
+	end
+	end
+	end
+
+	if steel_layer >= 96 then
+		for z = pos1.z+1, pos2.z-1 do
+		for y = pos1.y+1, pos2.y-1 do
+		for x = pos1.x+1, pos2.x-1 do
+			local vi = area:index(x, y, z)
+			if 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 data[vi] == c_steel then
+					data[vi] = c_lead
+				end
+			end
+		end
+		end
+		end
+		vm:set_data(data)
+		vm:write_to_map()
+		lead_layer = steel_layer
+	end
+
+	if water_layer > 25 then water_layer = 25 end
+	if lead_layer > 96 then lead_layer = 96 end
+	if blast_layer > 216 then blast_layer = 216 end
+	return (25 - water_layer) + (96 - lead_layer) + (216 - blast_layer)
+end
+
+
+local function melt_down_reactor(pos)
+	minetest.log("action", "A reactor melted down at "..minetest.pos_to_string(pos))
+	minetest.set_node(pos, {name = "technic:corium_source"})
+end
+
+
+local function start_reactor(pos, meta)
+	if minetest.get_node(pos).name ~= "technic:hv_nuclear_reactor_core" then
+		return false
+	end
+	local inv = meta:get_inventory()
+	if inv:is_empty("src") then
+		return false
+	end
+	local src_list = inv:get_list("src")
+	local correct_fuel_count = 0
+	for _, src_stack in pairs(src_list) do
+		if src_stack and src_stack:get_name() == fuel_type then
+			correct_fuel_count = correct_fuel_count + 1
+		end
+	end
+	-- Check that the reactor is complete and has the correct fuel
+	if correct_fuel_count ~= 6 or reactor_structure_badness(pos) ~= 0 then
+		return false
+	end
+	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, src_stack in pairs(src_list) do
+		src_stack:take_item()
+		inv:set_stack("src", idx, src_stack)
+	end
+	return true
+end
+
+
+minetest.register_abm({
+	label = "Machines: reactor melt-down check",
+	nodenames = {"technic:hv_nuclear_reactor_core_active"},
+	interval = 4,
+	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", math.max(accum_badness - 4, 0))
+				siren_clear(pos, meta)
+			end
+		else
+			siren_danger(pos, meta)
+			accum_badness = accum_badness + badness
+			if accum_badness >= 25 then
+				melt_down_reactor(pos)
+			else
+				meta:set_int("structure_accumulated_badness", accum_badness)
+			end
+		end
+	end,
+})
+
+local function run(pos, node)
+	local meta = minetest.get_meta(pos)
+	local burn_time = meta:get_int("burn_time") or 0
+	if burn_time >= burn_ticks or burn_time == 0 then
+		if has_digilines and meta:get_int("HV_EU_supply") == power_supply then
+			digilines.receptor_send(pos, technic.digilines.rules, meta:get_string("remote_channel"), {
+					command = "fuel_used",
+					pos = pos
+			})
+		end
+		if meta:get_string("autostart") == "true" then
+			if start_reactor(pos, meta) then
+				return
+			end
+		end
+		meta:set_int("HV_EU_supply", 0)
+		meta:set_int("burn_time", 0)
+		meta:set_string("infotext", S("%s Idle"):format(reactor_desc))
+		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", reactor_desc.." ("..percent.."%)")
+		meta:set_int("HV_EU_supply", power_supply)
+	end
+end
+
+local nuclear_reactor_receive_fields = function(pos, formname, fields, sender)
+	local player_name = sender:get_player_name()
+	if minetest.is_protected(pos, player_name) then
+		minetest.chat_send_player(player_name, "You are not allowed to edit this!")
+		minetest.record_protection_violation(pos, player_name)
+		return
+	end
+	local meta = minetest.get_meta(pos)
+	local update_formspec = false
+	if fields.remote_channel then
+		meta:set_string("remote_channel", fields.remote_channel)
+	end
+	if fields.start then
+		local b = start_reactor(pos, meta)
+		if b then
+			minetest.chat_send_player(player_name, "Start successful")
+		else
+			minetest.chat_send_player(player_name, "Error")
+		end
+	end
+	if fields.autostart then
+		meta:set_string("autostart", fields.autostart)
+		update_formspec = true
+	end
+	if fields.enable_digiline then
+		meta:set_string("enable_digiline", fields.enable_digiline)
+		update_formspec = true
+	end
+	if update_formspec then
+		meta:set_string("formspec", make_reactor_formspec(meta))
+	end
+end
+
+local digiline_def = function(pos, _, channel, msg)
+	local meta = minetest.get_meta(pos)
+	if meta:get_string("enable_digiline") ~= "true" or
+			channel ~= meta:get_string("remote_channel") then
+		return
+	end
+	-- Convert string messages to tables:
+	local msgt = type(msg)
+	if msgt == "string" then
+		local smsg = msg:lower()
+		msg = {}
+		if smsg == "get" then
+			msg.command = "get"
+		elseif smsg:sub(1, 13) == "self_destruct" then
+			msg.command = "self_destruct"
+			msg.timer = tonumber(smsg:sub(15)) or 0
+		elseif smsg == "start" then
+			msg.command = "start"
+		end
+	elseif msgt ~= "table" then
+		return
+	end
+
+	if msg.command == "get" then
+		local inv = meta:get_inventory()
+		local invtable = {}
+		for i = 1, 6 do
+			local stack = inv:get_stack("src", i)
+			if stack:is_empty() then
+				invtable[i] = 0
+			elseif stack:get_name() == fuel_type then
+				invtable[i] = stack:get_count()
+			else
+				invtable[i] = -stack:get_count()
+			end
+		end
+		digilines.receptor_send(pos, technic.digilines.rules, channel, {
+			burn_time = meta:get_int("burn_time"),
+			enabled   = meta:get_int("HV_EU_supply") == power_supply,
+			siren     = meta:get_int("siren") == 1,
+			structure_accumulated_badness = meta:get_int("structure_accumulated_badness"),
+			rods = invtable
+		})
+	elseif digiline_meltdown and msg.command == "self_destruct" and
+			minetest.get_node(pos).name == "technic:hv_nuclear_reactor_core_active" then
+		if msg.timer ~= 0 and type(msg.timer) == "number" then
+			siren_danger(pos, meta)
+			minetest.after(msg.timer, melt_down_reactor, pos)
+		else
+			melt_down_reactor(pos)
+		end
+	elseif msg.command == "start" then
+		local b = start_reactor(pos, meta)
+		if b then
+			digilines.receptor_send(pos, technic.digilines.rules, channel, {
+				command = "start_success",
+				pos = pos
+			})
+		else
+			digilines.receptor_send(pos, technic.digilines.rules, channel, {
+				command = "start_error",
+				pos = pos
+			})
+		end
+	end
+end
+
+minetest.register_node("technic:hv_nuclear_reactor_core", {
+	description = reactor_desc,
+	tiles = {
+		"technic_hv_nuclear_reactor_core.png",
+		"technic_hv_nuclear_reactor_core.png"..cable_entry
+	},
+	drawtype = "mesh",
+	mesh = "technic_reactor.obj",
+	groups = {cracky = 1, technic_machine = 1, technic_hv = 1},
+	legacy_facedir_simple = true,
+	sounds = default.node_sound_wood_defaults(),
+	paramtype = "light",
+	paramtype2 = "facedir",
+	stack_max = 1,
+	on_receive_fields = nuclear_reactor_receive_fields,
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", reactor_desc)
+		meta:set_string("formspec", make_reactor_formspec(meta))
+		if has_digilines then
+			meta:set_string("remote_channel",
+					"nuclear_reactor"..minetest.pos_to_string(pos))
+		end
+		local inv = meta:get_inventory()
+		inv:set_size("src", 6)
+	end,
+
+	-- digiline interface
+	digiline = {
+		receptor = {
+			rules = technic.digilines.rules,
+			action = function() end,
+		},
+		effector = {
+			rules = technic.digilines.rules,
+			action = digiline_def,
+		},
+	},
+
+	can_dig = technic.machine_can_dig,
+	on_destruct = function(pos) siren_set_state(pos, SS_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"..cable_entry
+	},
+	drawtype = "mesh",
+	mesh = "technic_reactor.obj",
+	groups = {cracky = 1, technic_machine = 1, technic_hv = 1, radioactive = 4,
+		not_in_creative_inventory = 1},
+	legacy_facedir_simple = true,
+	sounds = default.node_sound_wood_defaults(),
+	drop = "technic:hv_nuclear_reactor_core",
+	light_source = 14,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	on_receive_fields = nuclear_reactor_receive_fields,
+
+	-- digiline interface
+	digiline = {
+		receptor = {
+			rules = technic.digilines.rules,
+			action = function() end,
+		},
+		effector = {
+			rules = technic.digilines.rules,
+			action = digiline_def,
+		},
+	},
+
+	can_dig = technic.machine_can_dig,
+	after_dig_node = melt_down_reactor,
+	on_destruct = function(pos) siren_set_state(pos, SS_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)
+		-- Connected back?
+		if technic.get_timeout("HV", pos) > 0 then return false end
+
+		local meta = minetest.get_meta(pos)
+		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)

mods/technic_plus/technic/machines/HV/quarry.lua

@@ -0,0 +1,421 @@
+
+local S = technic.getter
+
+local has_digilines = minetest.get_modpath("digilines")
+
+local quarry_dig_above_nodes = tonumber(technic.config:get("quarry_dig_above_nodes"))
+local quarry_max_depth = tonumber(technic.config:get("quarry_max_depth"))
+local quarry_time_limit = tonumber(technic.config:get("quarry_time_limit"))
+
+local quarry_demand = 10000
+local quarry_eject_dir = vector.new(0, 1, 0)
+local machine_name = S("%s Quarry"):format("HV")
+local quarry_formspec =
+	"size[8,9]"..
+	"item_image[7,0;1,1;technic:quarry]"..
+	"list[context;cache;0,1;4,3;]"..
+	"listring[context;cache]"..
+	"list[current_player;main;0,5;8,4;]"..
+	"listring[current_player;main]"..
+	"label[0,0;"..machine_name.."]"..
+	"button[6,0.9;2,1;restart;"..S("Restart").."]"
+
+if has_digilines then
+	quarry_formspec = quarry_formspec
+			.. "field[4.3,3.4;4,1;channel;Channel;${channel}]"
+end
+
+-- hard-coded spiral dig pattern for up to 17x17 dig area
+local quarry_dig_pattern = {
+	0,1,2,2,3,3,0,0,0,1,1,1,2,2,2,2,3,3,3,3,0,0,0,0,0,1,1,1,1,1,2,2,
+	2,2,2,2,3,3,3,3,3,3,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,
+	3,3,3,3,3,3,3,3,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,
+	2,2,2,2,3,3,3,3,3,3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,
+	1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,0,
+	0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,
+	2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+	0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+	3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+}
+
+local function is_player_allowed(pos, name)
+	local owner = minetest.get_meta(pos):get_string("owner")
+	if owner == "" or owner == name then
+		return true
+	end
+	if not minetest.is_protected(pos, name) then
+		return true
+	end
+	return false
+end
+
+local function reset_quarry(pos)
+	local meta = minetest.get_meta(pos)
+	local node = technic.get_or_load_node(pos) or minetest.get_node(pos)
+	meta:set_int("quarry_dir", node.param2)
+	meta:set_string("quarry_pos", minetest.pos_to_string(pos))
+	meta:set_string("dig_pos", "")
+	meta:set_int("dig_level", pos.y + quarry_dig_above_nodes)
+	local radius = meta:get_int("size")
+	local diameter = (radius*2)+1
+	meta:set_int("dig_steps", diameter*diameter)
+	meta:set_int("dig_index", 0)
+	meta:set_int("purge_on", 1)
+	meta:set_int("finished", 0)
+	meta:set_int("dug", 0)
+end
+
+local function set_quarry_status(pos)
+	local meta = minetest.get_meta(pos)
+	local formspec = quarry_formspec.."field[4.3,2.4;2,1;size;"..S("Radius:")..";"..meta:get_int("size").."]"
+	local status = S("Digging not started")
+	if meta:get_int("enabled") == 1 then
+		formspec = formspec.."button[4,0.9;2,1;disable;"..S("Enabled").."]"
+		if meta:get_int("purge_on") == 1 then
+			status = S("Purging cache")
+			meta:set_string("infotext", S("%s purging cache"):format(machine_name))
+			meta:set_int("HV_EU_demand", 0)
+		elseif meta:get_int("finished") == 1 then
+			status = S("Digging finished")
+			meta:set_string("infotext", S("%s Finished"):format(machine_name))
+			meta:set_int("HV_EU_demand", 0)
+		else
+			local rel_y = meta:get_int("dig_level") - pos.y
+			status = S("Digging %d m "..(rel_y > 0 and "above" or "below").." machine"):format(math.abs(rel_y))
+			if meta:get_int("HV_EU_input") >= quarry_demand then
+				meta:set_string("infotext", S("%s Active"):format(machine_name))
+			else
+				meta:set_string("infotext", S("%s Unpowered"):format(machine_name))
+			end
+			meta:set_int("HV_EU_demand", quarry_demand)
+		end
+	else
+		formspec = formspec.."button[4,0.9;2,1;enable;"..S("Disabled").."]"
+		meta:set_string("infotext", S("%s Disabled"):format(machine_name))
+		meta:set_int("HV_EU_demand", 0)
+	end
+	meta:set_string("formspec", formspec.."label[0,4.1;"..minetest.formspec_escape(status).."]")
+end
+
+local function quarry_receive_fields(pos, formname, fields, sender)
+	local player_name = sender:get_player_name()
+	if not is_player_allowed(pos, player_name) then
+		minetest.chat_send_player(player_name, "You are not allowed to edit this!")
+		minetest.record_protection_violation(pos, player_name)
+		return
+	end
+	local meta = minetest.get_meta(pos)
+	if fields.size and string.find(fields.size, "^[0-9]+$") then
+		local size = tonumber(fields.size)
+		if size >= 1 and size <= 8 and size ~= meta:get_int("size") then
+			meta:set_int("size", size)
+			reset_quarry(pos)
+		end
+	end
+	if fields.channel then
+		meta:set_string("channel", fields.channel)
+	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 reset_quarry(pos) end
+	set_quarry_status(pos)
+end
+
+local function quarry_handle_purge(pos)
+	local meta = minetest.get_meta(pos)
+	local inv = meta:get_inventory()
+	local cache = inv:get_list("cache")
+	if not cache then
+		inv:set_size("cache", 12)
+		return
+	end
+	local i = 0
+	for _,stack in ipairs(cache) do
+		i = i + 1
+		if stack then
+			local item = stack:to_table()
+			if item then
+				technic.tube_inject_item(pos, pos, quarry_eject_dir, 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 can_dig_node(pos, node_name, owner, digger)
+	if node_name == "air" or node_name == "vacuum:vacuum" then
+		return false
+	end
+	local def = minetest.registered_nodes[node_name]
+	if not def or not def.diggable or (def.can_dig and not def.can_dig(pos, digger)) then
+		return false
+	end
+	if minetest.is_protected(pos, owner) then
+		return false
+	end
+	return true
+end
+
+local function find_ground(quarry_pos, quarry_dir, meta)
+	local dir = minetest.facedir_to_dir(quarry_dir % 4)
+	local radius = meta:get_int("size")
+	local dig_level = meta:get_int("dig_level")
+	local middle_pos = vector.add(quarry_pos, vector.multiply(dir, radius + 1))
+	local pos1 = vector.new(middle_pos.x - radius, dig_level, middle_pos.z - radius)
+	local pos2 = vector.new(middle_pos.x + radius, dig_level, middle_pos.z + radius)
+	local nodes = minetest.find_nodes_in_area(pos1, pos2, {"air", "vacuum:vacuum"})
+	if #nodes < meta:get_int("dig_steps") then
+		return vector.new(middle_pos.x, dig_level, middle_pos.z)
+	end
+	meta:set_int("dig_level", dig_level - 1)
+	return nil
+end
+
+local function get_dig_pos(quarry_pos, quarry_dir, dig_pos, dig_index, dig_steps, meta)
+	if dig_index > 0 and dig_index < dig_steps then
+		local facedir = (quarry_dir + quarry_dig_pattern[dig_index]) % 4
+		dig_pos = vector.add(dig_pos, minetest.facedir_to_dir(facedir))
+	elseif dig_index >= dig_steps then
+		local dig_level = meta:get_int("dig_level")
+		if (quarry_pos.y - dig_level) >= quarry_max_depth then
+			return nil, dig_index
+		end
+		local dir = minetest.facedir_to_dir(quarry_dir % 4)
+		dig_pos = vector.add(quarry_pos, vector.multiply(dir, meta:get_int("size") + 1))
+		dig_pos.y = dig_level - 1
+		meta:set_int("dig_level", dig_pos.y)
+		dig_index = 0
+	end
+	dig_index = dig_index + 1
+	return dig_pos, dig_index
+end
+
+local function execute_dig(pos, node, meta)
+	local dig_pos = minetest.string_to_pos(meta:get_string("dig_pos"))
+	local quarry_dir = meta:get_int("quarry_dir")
+	if not dig_pos then
+		-- quarry has not hit ground yet
+		dig_pos = find_ground(pos, quarry_dir, meta)
+	else
+		local owner = meta:get_string("owner")
+		local digger = pipeworks.create_fake_player({name = owner})
+		local dig_steps = meta:get_int("dig_steps")
+		local dig_index = meta:get_int("dig_index")
+		local t0 = minetest.get_us_time()
+		local us_used = 0
+		-- search for something to dig
+		while us_used < quarry_time_limit do
+			dig_pos, dig_index = get_dig_pos(pos, quarry_dir, dig_pos, dig_index, dig_steps, meta)
+			if not dig_pos then
+				-- finished digging
+				meta:set_int("finished", 1)
+				meta:set_int("purge_on", 1)
+				break
+			end
+			local dig_node = technic.get_or_load_node(dig_pos) or minetest.get_node(dig_pos)
+			if can_dig_node(dig_pos, dig_node.name, owner, digger) then
+				-- found something to dig, dig it and stop searching
+				minetest.remove_node(dig_pos)
+				local inv = meta:get_inventory()
+				local drops = minetest.get_node_drops(dig_node.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
+				local dug_nodes = meta:get_int("dug") + 1
+				meta:set_int("dug", dug_nodes)
+				if dug_nodes % 100 == 0 then
+					meta:set_int("purge_on", 1)
+				end
+				break
+			end
+			us_used = minetest.get_us_time() - t0
+		end
+		meta:set_int("dig_index", dig_index)
+	end
+	if dig_pos then
+		meta:set_string("dig_pos", minetest.pos_to_string(dig_pos))
+	end
+end
+
+local function quarry_run(pos, node)
+	local meta = minetest.get_meta(pos)
+	if minetest.pos_to_string(pos) ~= meta:get_string("quarry_pos") then
+		-- quarry has been moved since last dig
+		reset_quarry(pos)
+	elseif meta:get_int("purge_on") == 1 then
+		quarry_handle_purge(pos)
+	elseif meta:get_int("enabled") and meta:get_int("HV_EU_input") >= quarry_demand and meta:get_int("finished") == 0 then
+		execute_dig(pos, node, meta)
+	elseif not meta:get_inventory():is_empty("cache") then
+		meta:set_int("purge_on", 1)
+	end
+	set_quarry_status(pos)
+end
+
+local digiline_def = function(pos, _, channel, msg)
+	local meta = minetest.get_meta(pos)
+	if channel ~= meta:get_string("channel") then
+		return
+	end
+	-- Convert string messages to tables:
+	if type(msg) == "string" then
+		local smsg = msg:lower()
+		msg = {}
+		if smsg == "get" then
+			msg.command = "get"
+		elseif smsg:sub(1,7) == "radius " then
+			msg.command = "radius"
+			msg.value = smsg:sub(8,-1)
+		elseif smsg == "on" then
+			msg.command = "on"
+		elseif smsg == "off" then
+			msg.command = "off"
+		elseif smsg == "restart" then
+			msg.command = "restart"
+		end
+	end
+
+	if type(msg) ~= "table" then
+		return
+	end
+
+	if msg.command == "get" then
+		digilines.receptor_send(pos, technic.digilines.rules, channel, {
+			enabled = meta:get_int("enabled"),
+			radius = meta:get_int("size"),
+			finished = meta:get_int("finished"),
+			dug_nodes = meta:get_int("dug"),
+			dig_level = meta:get_int("dig_level") - pos.y
+		})
+	elseif msg.command == "radius" then
+		local size = tonumber(msg.value)
+		if not size or size < 1 or size > 8 or size == meta:get_int("size") then
+			return
+		end
+		meta:set_int("size", size)
+		reset_quarry(pos)
+		set_quarry_status(pos)
+	elseif msg.command == "on" then
+		meta:set_int("enabled", 1)
+		set_quarry_status(pos)
+	elseif msg.command == "off" then
+		meta:set_int("enabled", 0)
+		set_quarry_status(pos)
+	elseif msg.command == "restart" then
+		reset_quarry(pos)
+		set_quarry_status(pos)
+	end
+
+end
+
+minetest.register_node("technic:quarry", {
+	description = S("%s Quarry"):format("HV"),
+	tiles = {
+		"technic_carbon_steel_block.png^pipeworks_tube_connection_metallic.png",
+		"technic_carbon_steel_block.png^technic_cable_connection_overlay.png",
+		"technic_carbon_steel_block.png^technic_cable_connection_overlay.png",
+		"technic_carbon_steel_block.png^technic_cable_connection_overlay.png",
+		"technic_carbon_steel_block.png^default_tool_mesepick.png",
+		"technic_carbon_steel_block.png^technic_cable_connection_overlay.png"
+	},
+	paramtype2 = "facedir",
+	groups = {cracky=2, tubedevice=1, technic_machine=1, technic_hv=1},
+	connect_sides = {"bottom", "front", "left", "right"},
+	tube = {
+		connect_sides = {top = 1},
+		-- lower priority than other tubes, so that quarries will prefer any
+		-- other tube to another quarry, which could lead to server freezes
+		-- in certain quarry placements (2x2 for example would never eject)
+		priority = 10,
+		can_go = function(pos, node, velocity, stack)
+			-- always eject the same, even if items came in another way
+			-- this further mitigates loops and generally avoids random sideway movement
+			-- that can be expected in certain quarry placements
+			return { quarry_eject_dir }
+		end
+	},
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_int("size", 4)
+		meta:get_inventory():set_size("cache", 12)
+		reset_quarry(pos)
+		set_quarry_status(pos)
+	end,
+	on_rotate = function(pos, node, player, click, new_param2)
+		local meta = minetest.get_meta(pos)
+		if meta:get_int("enabled") == 1 then
+			return false
+		end
+
+		-- only allow rotation around y-axis
+		node.param2 = new_param2 % 4
+
+		minetest.swap_node(pos, node)
+		reset_quarry(pos)
+		set_quarry_status(pos)
+		return true
+	end,
+	after_place_node = function(pos, placer, itemstack)
+		minetest.get_meta(pos):set_string("owner", placer:get_player_name())
+		pipeworks.scan_for_tube_objects(pos)
+	end,
+	can_dig = function(pos,player)
+		return minetest.get_meta(pos):get_inventory():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 is_player_allowed(pos, player:get_player_name()) and count or 0
+	end,
+	allow_metadata_inventory_put = function(pos, listname, index, stack, player)
+		return is_player_allowed(pos, player:get_player_name()) and stack:get_count() or 0
+	end,
+	allow_metadata_inventory_take = function(pos, listname, index, stack, player)
+		return is_player_allowed(pos, player:get_player_name()) and stack:get_count() or 0
+	end,
+	mesecons = {
+		effector = {
+			action_on = function(pos)
+				local meta = minetest.get_meta(pos)
+				meta:set_int("enabled", 1)
+				set_quarry_status(pos)
+			end,
+			action_off = function(pos)
+				local meta = minetest.get_meta(pos)
+				meta:set_int("enabled", 0)
+				set_quarry_status(pos)
+			end
+		}
+	},
+	digiline = {
+		receptor = {
+			rules = technic.digilines.rules,
+			action = function() end,
+		},
+		effector = {
+			rules = technic.digilines.rules,
+			action = digiline_def,
+		},
+	},
+})
+
+minetest.register_craft({
+	recipe = {
+		{"technic:carbon_plate", "pipeworks:filter", "technic:composite_plate"},
+		{"basic_materials:motor", "technic:machine_casing", "technic:diamond_drill_head"},
+		{"technic:carbon_steel_block", "technic:hv_cable", "technic:carbon_steel_block"}},
+	output = "technic:quarry"
+})
+
+technic.register_machine("HV", "technic:quarry", technic.receiver)

mods/technic_plus/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_cable',       ''},
+	}
+})
+
+technic.register_solar_array({tier="HV", power=100})
+

mods/technic_plus/technic/machines/LV/alloy_furnace.lua

@@ -0,0 +1,14 @@
+-- LV Alloy furnace
+
+-- FIXME: kpoppel: I'd like to introduce an induction heating element here...
+minetest.register_craft({
+	output = 'technic:lv_alloy_furnace',
+	recipe = {
+		{'default:brick', 'default:brick',          'default:brick'},
+		{'default:brick', 'technic:machine_casing', 'default:brick'},
+		{'default:brick', 'technic:lv_cable',       'default:brick'},
+	}
+})
+
+technic.register_alloy_furnace({tier = "LV", speed = 1, demand = {300}})
+

mods/technic_plus/technic/machines/LV/battery_box.lua

@@ -0,0 +1,20 @@
+-- LV Battery box
+
+minetest.register_craft({
+	output = 'technic:lv_battery_box0',
+	recipe = {
+		{'group:wood',      'group:wood',             'group:wood'},
+		{'technic:battery', 'technic:machine_casing', 'technic:battery'},
+		{'technic:battery', 'technic:lv_cable',       'technic:battery'},
+	}
+})
+
+technic.register_battery_box({
+	tier           = "LV",
+	max_charge     = 40000,
+	charge_rate    = 1000,
+	discharge_rate = 4000,
+	charge_step    = 500,
+	discharge_step = 800,
+})
+

mods/technic_plus/technic/machines/LV/cables.lua

@@ -0,0 +1,50 @@
+
+minetest.register_alias("lv_cable", "technic:lv_cable")
+
+minetest.register_craft({
+	output = 'technic:lv_cable 6',
+	recipe = {
+		{'default:paper',        'default:paper',        'default:paper'},
+		{'default:copper_ingot', 'default:copper_ingot', 'default:copper_ingot'},
+		{'default:paper',        'default:paper',        'default:paper'},
+	}
+})
+
+technic.register_cable("LV", 2/16)
+
+if minetest.get_modpath("digilines") then
+
+	local S = technic.getter
+
+	if minetest.get_modpath("digistuff") then
+		minetest.register_craft({
+			output = 'technic:lv_digi_cable 1',
+			type = "shapeless",
+			recipe = {'digistuff:digimese', 'technic:lv_cable'}
+		})
+	else
+		minetest.register_craft({
+			output = 'technic:lv_digi_cable 1',
+			recipe = {
+				{'digilines:wire_std_00000000', 'digilines:wire_std_00000000', 'digilines:wire_std_00000000'},
+				{'digilines:wire_std_00000000', 'technic:lv_cable',            'digilines:wire_std_00000000'},
+				{'digilines:wire_std_00000000', 'digilines:wire_std_00000000', 'digilines:wire_std_00000000'},
+			}
+		})
+	end
+
+	technic.register_cable("LV", 2/16, S("LV Cable (digiline)"), "_digi", {
+		digiline = {
+			wire = {
+				rules = {
+					{x = 1, y = 0, z = 0},
+					{x =-1, y = 0, z = 0},
+					{x = 0, y = 1, z = 0},
+					{x = 0, y =-1, z = 0},
+					{x = 0, y = 0, z = 1},
+					{x = 0, y = 0, z =-1}
+				}
+			}
+		}
+	})
+end

mods/technic_plus/technic/machines/LV/compressor.lua

@@ -0,0 +1,17 @@
+
+minetest.register_alias("compressor", "technic:lv_compressor")
+
+minetest.register_craft({
+	output = 'technic:lv_compressor',
+	recipe = {
+		{'default:stone',            'basic_materials:motor',          'default:stone'},
+		{'mesecons:piston',          'technic:machine_casing', 'mesecons:piston'},
+		{'basic_materials:silver_wire', 'technic:lv_cable',       'basic_materials:silver_wire'},
+	},
+	replacements = {
+		{"basic_materials:silver_wire", "basic_materials:empty_spool"},
+		{"basic_materials:silver_wire", "basic_materials:empty_spool"}
+	},
+})
+
+technic.register_compressor({tier = "LV", demand = {300}, speed = 1})

mods/technic_plus/technic/machines/LV/electric_furnace.lua

@@ -0,0 +1,16 @@
+-- LV Electric Furnace
+-- This is a faster version of the stone furnace which runs on EUs
+
+-- FIXME: kpoppel I'd like to introduce an induction heating element here also
+minetest.register_craft({
+	output = 'technic:electric_furnace',
+	recipe = {
+		{'default:cobble', 'default:cobble',         'default:cobble'},
+		{'default:cobble', 'technic:machine_casing', 'default:cobble'},
+		{'default:cobble', 'technic:lv_cable',       'default:cobble'},
+	}
+})
+
+technic.register_electric_furnace({tier="LV", demand={300}, speed = 2})
+
+

mods/technic_plus/technic/machines/LV/extractor.lua

@@ -0,0 +1,13 @@
+
+minetest.register_alias("extractor", "technic:lv_extractor")
+
+minetest.register_craft({
+	output = 'technic:lv_extractor',
+	recipe = {
+		{'technic:treetap', 'basic_materials:motor',          'technic:treetap'},
+		{'technic:treetap', 'technic:machine_casing', 'technic:treetap'},
+		{'',                'technic:lv_cable',       ''},
+	}
+})
+
+technic.register_extractor({tier = "LV", demand = {300}, speed = 1})

mods/technic_plus/technic/machines/LV/generator.lua

@@ -0,0 +1,18 @@
+-- The electric generator.
+-- A simple device to get started on the electric machines.
+-- Inefficient and expensive in fuel (200EU per tick)
+-- Also only allows for LV machinery to run.
+
+minetest.register_alias("lv_generator", "technic:lv_generator")
+
+minetest.register_craft({
+	output = 'technic:lv_generator',
+	recipe = {
+		{'default:stone', 'default:furnace',        'default:stone'},
+		{'default:stone', 'technic:machine_casing', 'default:stone'},
+		{'default:stone', 'technic:lv_cable',       'default:stone'},
+	}
+})
+
+technic.register_generator({tier="LV", supply=200})
+

mods/technic_plus/technic/machines/LV/geothermal.lua

@@ -0,0 +1,117 @@
+-- A geothermal EU generator
+-- Using hot lava and water this device can create energy from steam
+-- The machine is only producing LV EUs and can thus not drive more advanced equipment
+-- The output is a little more than the coal burning generator (max 300EUs)
+
+minetest.register_alias("geothermal", "technic:geothermal")
+
+local S = technic.getter
+
+minetest.register_craft({
+	output = 'technic:geothermal',
+	recipe = {
+		{'technic:granite',          'default:diamond',        'technic:granite'},
+		{'basic_materials:copper_wire', 'technic:machine_casing', 'basic_materials:copper_wire'},
+		{'technic:granite',          'technic:lv_cable',       'technic:granite'},
+	},
+	replacements = {
+		{"basic_materials:copper_wire", "basic_materials:empty_spool"},
+		{"basic_materials:copper_wire", "basic_materials:empty_spool"}
+	},
+})
+
+minetest.register_craftitem("technic:geothermal", {
+	description = S("Geothermal %s Generator"):format("LV"),
+})
+
+local check_node_around = function(pos)
+	local node = minetest.get_node(pos)
+	if node.name == "default:water_source" or node.name == "default:water_flowing" then return 1 end
+	if node.name == "default:lava_source"  or node.name == "default:lava_flowing"  then return 2 end
+	return 0
+end
+
+local run = function(pos, node)
+	local meta             = minetest.get_meta(pos)
+	local water_nodes      = 0
+	local lava_nodes       = 0
+	local production_level = 0
+	local eu_supply        = 0
+
+	-- Correct positioning is water on one side and lava on the other.
+	-- The two cannot be adjacent because the lava the turns into obsidian or rock.
+	-- To get to 100% production stack the water and lava one extra block down as well:
+	--    WGL (W=Water, L=Lava, G=the generator, |=an LV cable)
+	--    W|L
+
+	local positions = {
+		{x=pos.x+1, y=pos.y,   z=pos.z},
+		{x=pos.x+1, y=pos.y-1, z=pos.z},
+		{x=pos.x-1, y=pos.y,   z=pos.z},
+		{x=pos.x-1, y=pos.y-1, z=pos.z},
+		{x=pos.x,   y=pos.y,   z=pos.z+1},
+		{x=pos.x,   y=pos.y-1, z=pos.z+1},
+		{x=pos.x,   y=pos.y,   z=pos.z-1},
+		{x=pos.x,   y=pos.y-1, z=pos.z-1},
+	}
+	for _, p in pairs(positions) do
+		local check = check_node_around(p)
+		if check == 1 then water_nodes = water_nodes + 1 end
+		if check == 2 then lava_nodes  = lava_nodes  + 1 end
+	end
+
+	if water_nodes == 1 and lava_nodes == 1 then production_level =  25; eu_supply = 50 end
+	if water_nodes == 2 and lava_nodes == 1 then production_level =  50; eu_supply = 100 end
+	if water_nodes == 1 and lava_nodes == 2 then production_level =  75; eu_supply = 200 end
+	if water_nodes == 2 and lava_nodes == 2 then production_level = 100; eu_supply = 300 end
+
+	if production_level > 0 then
+		meta:set_int("LV_EU_supply", eu_supply)
+	end
+
+	meta:set_string("infotext",
+		S("Geothermal %s Generator"):format("LV").." ("..production_level.."%)")
+
+	if production_level > 0 and minetest.get_node(pos).name == "technic:geothermal" then
+		technic.swap_node (pos, "technic:geothermal_active")
+		return
+	end
+	if production_level == 0 then
+		technic.swap_node(pos, "technic:geothermal")
+		meta:set_int("LV_EU_supply", 0)
+	end
+end
+
+minetest.register_node("technic:geothermal", {
+	description = S("Geothermal %s Generator"):format("LV"),
+	tiles = {"technic_geothermal_top.png", "technic_machine_bottom.png", "technic_geothermal_side.png",
+	         "technic_geothermal_side.png", "technic_geothermal_side.png", "technic_geothermal_side.png"},
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+		technic_machine=1, technic_lv=1},
+	paramtype2 = "facedir",
+	legacy_facedir_simple = true,
+	sounds = default.node_sound_wood_defaults(),
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("Geothermal %s Generator"):format("LV"))
+		meta:set_int("LV_EU_supply", 0)
+	end,
+	technic_run = run,
+})
+
+minetest.register_node("technic:geothermal_active", {
+	description = S("Geothermal %s Generator"):format("LV"),
+	tiles = {"technic_geothermal_top_active.png", "technic_machine_bottom.png", "technic_geothermal_side.png",
+	         "technic_geothermal_side.png", "technic_geothermal_side.png", "technic_geothermal_side.png"},
+	paramtype2 = "facedir",
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+		technic_machine=1, technic_lv=1, not_in_creative_inventory=1},
+	legacy_facedir_simple = true,
+	sounds = default.node_sound_wood_defaults(),
+	drop = "technic:geothermal",
+	technic_run = run,
+})
+
+technic.register_machine("LV", "technic:geothermal",        technic.producer)
+technic.register_machine("LV", "technic:geothermal_active", technic.producer)
+

mods/technic_plus/technic/machines/LV/grinder.lua

@@ -0,0 +1,13 @@
+
+minetest.register_alias("grinder", "technic:lv_grinder")
+minetest.register_craft({
+	output = 'technic:lv_grinder',
+	recipe = {
+		{'default:desert_stone', 'default:diamond',        'default:desert_stone'},
+		{'default:desert_stone', 'technic:machine_casing', 'default:desert_stone'},
+		{'technic:granite',      'technic:lv_cable',       'technic:granite'},
+	}
+})
+
+technic.register_grinder({tier="LV", demand={200}, speed=1})
+

mods/technic_plus/technic/machines/LV/init.lua

@@ -0,0 +1,26 @@
+
+technic.register_tier("LV", "Low Voltage")
+
+local path = technic.modpath.."/machines/LV"
+
+-- Wiring stuff
+dofile(path.."/cables.lua")
+dofile(path.."/battery_box.lua")
+
+-- Generators
+dofile(path.."/solar_panel.lua")
+dofile(path.."/solar_array.lua")
+dofile(path.."/geothermal.lua")
+dofile(path.."/water_mill.lua")
+dofile(path.."/generator.lua")
+
+-- Machines
+dofile(path.."/alloy_furnace.lua")
+dofile(path.."/electric_furnace.lua")
+dofile(path.."/grinder.lua")
+dofile(path.."/extractor.lua")
+dofile(path.."/compressor.lua")
+
+dofile(path.."/music_player.lua")
+
+dofile(path.."/lamp.lua")

mods/technic_plus/technic/machines/LV/lamp.lua

@@ -0,0 +1,246 @@
+-- LV LED and LV LED Lamp
+-- LED - a weak light source, intended primarily as a core component for LED lamps
+-- LED Lamp - a powerful light source, illuminating a 7x7x3(H) volume below itself
+-- with light bright as the sun.
+
+local S = technic.getter
+
+
+local illuminate = function(pos, mode)
+	for y=1,3,1 do
+		for x=-3,3,1 do
+			for z = -3,3,1 do
+				local loc = {x = pos.x - x, y = pos.y - y, z = pos.z - z}
+				if mode then
+					if minetest.get_node(loc).name == "air" then
+						minetest.swap_node(loc, {name = "technic:dummy_light_source"})
+					end
+				else
+					if minetest.get_node(loc).name == "technic:dummy_light_source" then
+						minetest.swap_node(loc, {name = "air"})
+					end
+				end
+			end
+		end
+	end
+end
+
+
+local led_on = function(pos, node)
+	local meta         = minetest.get_meta(pos)
+	local eu_input     = meta:get_int("LV_EU_input")
+	local machine_name = S("%s LED"):format("LV")
+	local machine_node = "technic:lv_led"
+	local demand       = 5
+
+	if eu_input < demand then
+		technic.swap_node(pos, machine_node)
+		meta:set_string("infotext", S("%s Unpowered"):format(machine_name))
+	elseif eu_input >= demand then
+		technic.swap_node(pos, machine_node.."_active")
+		meta:set_string("infotext", S("%s Active"):format(machine_name))
+	end
+	meta:set_int("LV_EU_demand", demand)
+end
+
+local led_off = function(pos, node)
+	local meta         = minetest.get_meta(pos)
+	local machine_name = S("%s LED"):format("LV")
+	local machine_node = "technic:lv_led"
+
+	technic.swap_node(pos, machine_node)
+	meta:set_string("infotext", S("%s Unpowered"):format(machine_name))
+
+	meta:set_int("LV_EU_demand", 0)
+end
+
+
+
+local lamp_on = function(pos, node)
+	local meta         = minetest.get_meta(pos)
+	local eu_input     = meta:get_int("LV_EU_input")
+	local machine_name = S("%s Lamp"):format("LV")
+	local machine_node = "technic:lv_lamp"
+	local demand       = 50
+
+	if eu_input < demand then
+		technic.swap_node(pos, machine_node)
+		meta:set_string("infotext", S("%s Unpowered"):format(machine_name))
+		illuminate(pos, false)
+	elseif eu_input >= demand then
+		technic.swap_node(pos, machine_node.."_active")
+		meta:set_string("infotext", S("%s Active"):format(machine_name))
+		illuminate(pos, true)
+	end
+	meta:set_int("LV_EU_demand", demand)
+end
+
+local lamp_off = function(pos, node)
+	local meta         = minetest.get_meta(pos)
+	local machine_name = S("%s Lamp"):format("LV")
+	local machine_node = "technic:lv_lamp"
+
+	illuminate(pos, false)
+	technic.swap_node(pos, machine_node)
+	meta:set_string("infotext", S("%s Unpowered"):format(machine_name))
+	meta:set_int("LV_EU_demand", 0)
+end
+
+
+minetest.register_node("technic:dummy_light_source", {
+	description = S("Dummy light source node"),
+	node_box = {
+		type = "fixed",
+		fixed = {}
+		},
+	collision_box = {
+		type = "fixed",
+		fixed = {}
+		},
+	selection_box = {
+		type = "fixed",
+		fixed = {}
+		},
+	drawtype = "airlike",
+	buildable_to = true,
+	light_source = 14,
+	sunlight_propagates = true,
+	diggable = false,
+	walkable = false,
+	groups = { not_in_creative_inventory = 1 }
+})
+
+minetest.register_node("technic:lv_led", {
+	description = S("LV LED"),
+	drawtype = "nodebox",
+	node_box = {
+		type = "fixed",
+		fixed = {0.2,0.2,0.2,-0.2,-0.2,-0.2}
+		},
+	collision_box = {
+		type = "fixed",
+		fixed = {0.2,0.2,0.2,-0.2,-0.2,-0.2}
+		},
+	selection_box = {
+		type = "fixed",
+		fixed = {0.2,0.2,0.2,-0.2,-0.2,-0.2}
+		},
+	tiles = {"technic_lv_led.png"},
+	inventory_image = "technic_lv_led_inv.png",
+	sunlight_propagates = true,
+	groups = {cracky=2, technic_machine=1, technic_lv=1},
+	connect_sides = {"front", "back", "left", "right", "top", "bottom"},
+	can_dig = technic.machine_can_dig,
+	technic_run = led_on,
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("%s LED"):format("LV"))
+	end,
+	drop = "technic:lv_led"
+})
+
+minetest.register_node("technic:lv_led_active", {
+	description = S("LV LED Active"),
+	drawtype = "nodebox",
+	node_box = {
+		type = "fixed",
+		fixed = {0.2,0.2,0.2,-0.2,-0.2,-0.2}
+		},
+	collision_box = {
+		type = "fixed",
+		fixed = {0.2,0.2,0.2,-0.2,-0.2,-0.2}
+		},
+	selection_box = {
+		type = "fixed",
+		fixed = {0.2,0.2,0.2,-0.2,-0.2,-0.2}
+		},
+	tiles = {"technic_lv_led.png"},
+	light_source = 9,
+	sunlight_propagates = true,
+	groups = {cracky=2, technic_machine=1, technic_lv=1, not_in_creative_inventory=1},
+	connect_sides = {"front", "back", "left", "right", "top", "bottom"},
+	can_dig = technic.machine_can_dig,
+	technic_run = led_on,
+	technic_on_disable = led_off,
+	drop = "technic:lv_led"
+})
+
+
+minetest.register_node("technic:lv_lamp", {
+	description = S("%s Lamp"):format("LV"),
+	drawtype = "nodebox",
+	node_box = {
+		type = "fixed",
+		fixed = {0.5,0.5,0.5,-0.5,-0.2,-0.5}
+		},
+	collision_box = {
+		type = "fixed",
+		fixed = {0.5,0.5,0.5,-0.5,-0.2,-0.5}
+		},
+	selection_box = {
+		type = "fixed",
+		fixed = {0.5,0.5,0.5,-0.5,-0.2,-0.5}
+		},
+	tiles       = {"technic_lv_lamp_top.png", "technic_lv_lamp_bottom.png", "technic_lv_lamp_side.png",
+	               "technic_lv_lamp_side.png", "technic_lv_lamp_side.png", "technic_lv_lamp_side.png"},
+	groups = {cracky=2, technic_machine=1, technic_lv=1},
+	connect_sides = {"front", "back", "left", "right", "top",},
+	can_dig = technic.machine_can_dig,
+	technic_run = lamp_on,
+	on_destruct = lamp_off,
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("%s Lamp"):format("LV"))
+	end,
+})
+
+
+minetest.register_node("technic:lv_lamp_active", {
+	description = S("%s Lamp Active"):format("LV"),
+	drawtype = "nodebox",
+	node_box = {
+		type = "fixed",
+		fixed = {0.5,0.5,0.5,-0.5,-0.2,-0.5}
+		},
+	collision_box = {
+		type = "fixed",
+		fixed = {0.5,0.5,0.5,-0.5,-0.2,-0.5}
+		},
+	selection_box = {
+		type = "fixed",
+		fixed = {0.5,0.5,0.5,-0.5,-0.2,-0.5}
+		},
+	tiles       = {"technic_lv_lamp_top.png", "technic_lv_lamp_bottom.png", "technic_lv_lamp_side.png",
+	               "technic_lv_lamp_side.png", "technic_lv_lamp_side.png", "technic_lv_lamp_side.png"},
+	groups = {cracky=2, technic_machine=1, technic_lv=1, not_in_creative_inventory=1},
+	connect_sides = {"front", "back", "left", "right", "top"},
+	light_source = 1,
+	can_dig = technic.machine_can_dig,
+	technic_run = lamp_on,
+	on_destruct = lamp_off,
+	technic_on_disable = lamp_off,
+})
+
+minetest.register_craft({
+	output = 'technic:lv_led 2',
+	recipe = {
+		{'',                           'homedecor:plastic_sheeting',  ''},
+		{'homedecor:plastic_sheeting', 'technic:doped_silicon_wafer', 'homedecor:plastic_sheeting'},
+		{'',                           'technic:fine_silver_wire',    ''},
+	},
+})
+
+minetest.register_craft({
+	output = 'technic:lv_lamp',
+	recipe = {
+		{'default:glass',           'default:glass',    'default:glass'},
+		{'technic:lv_led',          'technic:lv_led',   'technic:lv_led'},
+		{'mesecons_materials:glue', 'technic:lv_cable', 'mesecons_materials:glue'},
+	},
+})
+
+technic.register_machine("LV", "technic:lv_lamp", technic.receiver)
+technic.register_machine("LV", "technic:lv_lamp_active", technic.receiver)
+
+technic.register_machine("LV", "technic:lv_led", technic.receiver)
+technic.register_machine("LV", "technic:lv_led_active", technic.receiver)

mods/technic_plus/technic/machines/LV/music_player.lua

@@ -0,0 +1,131 @@
+-- LV Music player.
+-- The player can play music. But it is high ampage!
+
+local S = technic.getter
+
+minetest.register_alias("music_player", "technic:music_player")
+minetest.register_craft({
+	output = 'technic:music_player',
+	recipe = {
+		{'technic:chromium_ingot', 'default:diamond',        'technic:chromium_ingot'},
+		{'default:diamond',        'technic:machine_casing', 'default:diamond'},
+		{'default:mossycobble',    'technic:lv_cable',       'default:mossycobble'},
+	}
+})
+
+local music_handles = {}
+
+local function play_track(pos, track)
+	return minetest.sound_play("technic_track"..tostring(track),
+			{pos = pos, gain = 1.0, loop = true, max_hear_distance = 72,})
+end
+
+local run = function(pos, node)
+	local meta         = minetest.get_meta(pos)
+	local eu_input     = meta:get_int("LV_EU_input")
+	local machine_name = S("%s Music Player"):format("LV")
+	local demand       = 150
+
+	local current_track = meta:get_int("current_track")
+	local pos_hash      = minetest.hash_node_position(pos)
+	local music_handle  = music_handles[pos_hash]
+
+	-- Setup meta data if it does not exist.
+	if not eu_input then
+		meta:set_int("LV_EU_demand", demand)
+		meta:set_int("LV_EU_input", 0)
+		return
+	end
+
+	if meta:get_int("active") == 0 then
+		meta:set_string("infotext", S("%s Idle"):format(machine_name))
+		meta:set_int("LV_EU_demand", 0)
+		return
+	end
+
+	if eu_input < demand then
+		meta:set_string("infotext", S("%s Unpowered"):format(machine_name))
+		if music_handle then
+			minetest.sound_stop(music_handle)
+			music_handle = nil
+		end
+	elseif eu_input >= demand then
+		meta:set_string("infotext", S("%s Active"):format(machine_name))
+		if not music_handle then
+			music_handle = play_track(pos, current_track)
+		end
+	end
+	music_handles[pos_hash] = music_handle
+	meta:set_int("LV_EU_demand", demand)
+end
+
+local function stop_player(pos, node)
+	local pos_hash = minetest.hash_node_position(pos)
+	local music_handle = music_handles[pos_hash]
+	if music_handle then
+		minetest.sound_stop(music_handle)
+		music_handles[pos_hash] = nil
+	end
+end
+
+local function set_display(meta)
+	meta:set_string("formspec",
+			"size[4,4.5]"..
+			"item_image[0,0;1,1;technic:music_player]"..
+			"label[1,0;"..S("%s Music Player"):format("LV").."]"..
+			"button[0,1;1,1;track1;1]"..
+			"button[1,1;1,1;track2;2]"..
+			"button[2,1;1,1;track3;3]"..
+			"button[0,2;1,1;track4;4]"..
+			"button[1,2;1,1;track5;5]"..
+			"button[2,2;1,1;track6;6]"..
+			"button[0,3;1,1;track7;7]"..
+			"button[1,3;1,1;track8;8]"..
+			"button[2,3;1,1;track9;9]"..
+			"button[3,1;1,1;stop;Stop]"..
+			"label[0,4;"..minetest.formspec_escape(
+				meta:get_int("active") == 0 and
+					S("Stopped") or
+					S("Current track %s"):format(meta:get_int("current_track"))).."]")
+end
+
+minetest.register_node("technic:music_player", {
+	description = S("%s Music Player"):format("LV"),
+	tiles = {"technic_music_player_top.png", "technic_machine_bottom.png", "technic_music_player_side.png",
+	         "technic_music_player_side.png", "technic_music_player_side.png", "technic_music_player_side.png"},
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+		technic_machine=1, technic_lv=1},
+	connect_sides = {"bottom"},
+	sounds = default.node_sound_wood_defaults(),
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("%s Music Player"):format("LV"))
+		set_display(meta)
+	end,
+	on_receive_fields = function(pos, formanme, fields, sender)
+		local new_track = nil
+		if fields.stop then new_track = 0 end
+		if fields.track1 then new_track = 1 end
+		if fields.track2 then new_track = 2 end
+		if fields.track3 then new_track = 3 end
+		if fields.track4 then new_track = 4 end
+		if fields.track5 then new_track = 5 end
+		if fields.track6 then new_track = 6 end
+		if fields.track7 then new_track = 7 end
+		if fields.track8 then new_track = 8 end
+		if fields.track9 then new_track = 9 end
+		if new_track then
+			stop_player(pos)
+			local meta = minetest.get_meta(pos)
+			meta:set_int("active", new_track == 0 and 0 or 1)
+			meta:set_int("current_track", new_track)
+			set_display(meta)
+		end
+	end,
+	on_destruct = stop_player,
+	technic_run = run,
+	technic_on_disable = stop_player,
+})
+
+technic.register_machine("LV", "technic:music_player", technic.receiver)
+

mods/technic_plus/technic/machines/LV/solar_array.lua

@@ -0,0 +1,18 @@
+-- The solar array is an assembly of panels into a powerful array
+-- The assembly can deliver more energy than the individual panel because
+-- of the transformer unit which converts the panel output variations into
+-- a stable supply.
+-- Solar arrays are not able to store large amounts of energy.
+-- The LV arrays are used to make medium voltage arrays.
+
+minetest.register_craft({
+	output = 'technic:solar_array_lv 1',
+	recipe = {
+		{'technic:solar_panel',        'technic:solar_panel',    'technic:solar_panel'},
+		{'technic:carbon_steel_ingot', 'technic:lv_transformer', 'technic:carbon_steel_ingot'},
+		{'',                           'technic:lv_cable',       ''},
+	}
+})
+
+technic.register_solar_array({tier="LV", power=10})
+

mods/technic_plus/technic/machines/LV/solar_panel.lua

@@ -0,0 +1,72 @@
+-- Solar panels are the building blocks of LV solar arrays
+-- They can however also be used separately but with reduced efficiency due to the missing transformer.
+-- Individual panels are less efficient than when the panels are combined into full arrays.
+
+local S = technic.getter
+
+
+minetest.register_craft({
+	output = 'technic:solar_panel',
+	recipe = {
+		{'technic:doped_silicon_wafer', 'technic:doped_silicon_wafer', 'technic:doped_silicon_wafer'},
+		{'basic_materials:silver_wire',    'technic:lv_cable',            'mesecons_materials:glue'},
+	},
+	replacements = { {"basic_materials:silver_wire", "basic_materials:empty_spool"}, },
+})
+
+
+local run = function(pos, node)
+	-- The action here is to make the solar panel prodice power
+	-- Power is dependent on the light level and the height above ground
+	-- There are many ways to cheat by using other light sources like lamps.
+	-- As there is no way to determine if light is sunlight that is just a shame.
+	-- To take care of some of it solar panels do not work outside daylight hours or if
+	-- built below 0m
+	local pos1 = {x=pos.x, y=pos.y+1, z=pos.z}
+	local machine_name = S("Small Solar %s Generator"):format("LV")
+
+	local light = minetest.get_node_light(pos1, nil)
+	local time_of_day = minetest.get_timeofday()
+	local meta = minetest.get_meta(pos)
+	if light == nil then light = 0 end
+	-- turn on panel only during day time and if sufficient light
+        -- I know this is counter intuitive when cheating by using other light sources underground.
+	if light >= 12 and time_of_day >= 0.24 and time_of_day <= 0.76 and pos.y > -10 then
+		local charge_to_give = math.floor((light + pos1.y) * 3)
+		charge_to_give = math.max(charge_to_give, 0)
+		charge_to_give = math.min(charge_to_give, 200)
+		meta:set_string("infotext", S("@1 Active (@2)", machine_name,
+			technic.EU_string(charge_to_give)))
+		meta:set_int("LV_EU_supply", charge_to_give)
+	else
+		meta:set_string("infotext", S("%s Idle"):format(machine_name))
+		meta:set_int("LV_EU_supply", 0)
+	end
+end
+
+minetest.register_node("technic:solar_panel", {
+	tiles = {"technic_solar_panel_top.png",  "technic_solar_panel_bottom.png", "technic_solar_panel_side.png",
+	         "technic_solar_panel_side.png", "technic_solar_panel_side.png",   "technic_solar_panel_side.png"},
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+		technic_machine=1, technic_lv=1},
+	connect_sides = {"bottom"},
+	sounds = default.node_sound_wood_defaults(),
+	description = S("Small Solar %s Generator"):format("LV"),
+	active = false,
+	drawtype = "nodebox",
+	paramtype = "light",
+	is_ground_content = true,
+	node_box = {
+		type = "fixed",
+		fixed = {-0.5, -0.5, -0.5, 0.5, 0, 0.5},
+	},
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_int("LV_EU_supply", 0)
+		meta:set_string("infotext", S("Small Solar %s Generator"):format("LV"))
+	end,
+	technic_run = run,
+})
+
+technic.register_machine("LV", "technic:solar_panel", technic.producer)
+

mods/technic_plus/technic/machines/LV/water_mill.lua

@@ -0,0 +1,109 @@
+-- A water mill produces LV EUs by exploiting flowing water across it
+-- It is a LV EU supplier and fairly low yield (max 180EUs)
+-- It is a little over half as good as the thermal generator.
+
+local S = technic.getter
+
+local cable_entry = "^technic_cable_connection_overlay.png"
+
+minetest.register_alias("water_mill", "technic:water_mill")
+
+minetest.register_craft({
+	output = 'technic:water_mill',
+	recipe = {
+		{'technic:marble', 'default:diamond',        'technic:marble'},
+		{'group:wood',     'technic:machine_casing', 'group:wood'},
+		{'technic:marble', 'technic:lv_cable',       'technic:marble'},
+	}
+})
+
+local function check_node_around_mill(pos)
+	local node = minetest.get_node(pos)
+	if node.name == "default:water_flowing"
+	  or node.name == "default:river_water_flowing" then
+		return node.param2 -- returns approx. water flow, if any
+	end
+	return false
+end
+
+local run = function(pos, node)
+	local meta             = minetest.get_meta(pos)
+	local water_flow       = 0
+	local production_level
+	local eu_supply
+	local max_output       = 4 * 45 -- keeping it around 180, little more than previous 150 :)
+
+	local positions = {
+		{x=pos.x+1, y=pos.y, z=pos.z},
+		{x=pos.x-1, y=pos.y, z=pos.z},
+		{x=pos.x,   y=pos.y, z=pos.z+1},
+		{x=pos.x,   y=pos.y, z=pos.z-1},
+	}
+
+	for _, p in pairs(positions) do
+		local check = check_node_around_mill(p)
+		if check then
+			water_flow = water_flow + check
+		end
+	end
+
+	eu_supply = math.min(4 * water_flow, max_output)
+	production_level = math.floor(100 * eu_supply / max_output)
+
+	meta:set_int("LV_EU_supply", eu_supply)
+
+	meta:set_string("infotext",
+		S("Hydro %s Generator"):format("LV").." ("..production_level.."%)")
+
+	if production_level > 0 and
+	   minetest.get_node(pos).name == "technic:water_mill" then
+		technic.swap_node (pos, "technic:water_mill_active")
+		meta:set_int("LV_EU_supply", 0)
+		return
+	end
+	if production_level == 0 then
+		technic.swap_node(pos, "technic:water_mill")
+	end
+end
+
+minetest.register_node("technic:water_mill", {
+	description = S("Hydro %s Generator"):format("LV"),
+	tiles = {
+		"technic_water_mill_top.png",
+		"technic_machine_bottom.png"..cable_entry,
+		"technic_water_mill_side.png",
+		"technic_water_mill_side.png",
+		"technic_water_mill_side.png",
+		"technic_water_mill_side.png"
+	},
+	paramtype2 = "facedir",
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+		technic_machine=1, technic_lv=1},
+	legacy_facedir_simple = true,
+	sounds = default.node_sound_wood_defaults(),
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("Hydro %s Generator"):format("LV"))
+		meta:set_int("LV_EU_supply", 0)
+	end,
+	technic_run = run,
+})
+
+minetest.register_node("technic:water_mill_active", {
+	description = S("Hydro %s Generator"):format("LV"),
+	tiles = {"technic_water_mill_top_active.png", "technic_machine_bottom.png",
+	         "technic_water_mill_side.png",       "technic_water_mill_side.png",
+	         "technic_water_mill_side.png",       "technic_water_mill_side.png"},
+	paramtype2 = "facedir",
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+		technic_machine=1, technic_lv=1, not_in_creative_inventory=1},
+	legacy_facedir_simple = true,
+	sounds = default.node_sound_wood_defaults(),
+	drop = "technic:water_mill",
+	technic_run = run,
+	technic_disabled_machine_name = "technic:water_mill",
+})
+
+technic.register_machine("LV", "technic:water_mill",        technic.producer)
+technic.register_machine("LV", "technic:water_mill_active", technic.producer)
+

mods/technic_plus/technic/machines/MV/alloy_furnace.lua

@@ -0,0 +1,14 @@
+-- MV alloy furnace
+
+minetest.register_craft({
+	output = 'technic:mv_alloy_furnace',
+	recipe = {
+		{'technic:stainless_steel_ingot', 'technic:lv_alloy_furnace', 'technic:stainless_steel_ingot'},
+		{'pipeworks:tube_1',              'technic:mv_transformer',   'pipeworks:tube_1'},
+		{'technic:stainless_steel_ingot', 'technic:mv_cable',         'technic:stainless_steel_ingot'},
+	}
+})
+
+
+technic.register_alloy_furnace({tier = "MV", speed = 1.5, upgrade = 1, tube = 1, demand = {3000, 2000, 1000}})
+

mods/technic_plus/technic/machines/MV/battery_box.lua

@@ -0,0 +1,22 @@
+-- MV Battery box
+
+minetest.register_craft({
+	output = 'technic:mv_battery_box0',
+	recipe = {
+		{'technic:lv_battery_box0', 'technic:lv_battery_box0', 'technic:lv_battery_box0'},
+		{'technic:lv_battery_box0', 'technic:mv_transformer',  'technic:lv_battery_box0'},
+		{'',                        'technic:mv_cable',        ''},
+	}
+})
+
+technic.register_battery_box({
+	tier           = "MV",
+	max_charge     = 200000,
+	charge_rate    = 20000,
+	discharge_rate = 80000,
+	charge_step    = 2000,
+	discharge_step = 8000,
+	upgrade        = 1,
+	tube           = 1,
+})
+

mods/technic_plus/technic/machines/MV/cables.lua

@@ -0,0 +1,50 @@
+
+minetest.register_alias("mv_cable", "technic:mv_cable")
+
+minetest.register_craft({
+	output = 'technic:mv_cable 3',
+	recipe ={
+		{'technic:rubber',   'technic:rubber',   'technic:rubber'},
+		{'technic:lv_cable', 'technic:lv_cable', 'technic:lv_cable'},
+		{'technic:rubber',   'technic:rubber',   'technic:rubber'},
+	}
+})
+
+technic.register_cable("MV", 2.5/16)
+
+if minetest.get_modpath("digilines") then
+
+	local S = technic.getter
+
+	if minetest.get_modpath("digistuff") then
+		minetest.register_craft({
+			output = 'technic:mv_digi_cable 1',
+			type = "shapeless",
+			recipe = {'digistuff:digimese', 'technic:mv_cable'}
+		})
+	else
+		minetest.register_craft({
+			output = 'technic:mv_digi_cable 1',
+			recipe = {
+				{'digilines:wire_std_00000000', 'digilines:wire_std_00000000', 'digilines:wire_std_00000000'},
+				{'digilines:wire_std_00000000', 'technic:mv_cable',            'digilines:wire_std_00000000'},
+				{'digilines:wire_std_00000000', 'digilines:wire_std_00000000', 'digilines:wire_std_00000000'},
+			}
+		})
+	end
+
+	technic.register_cable("MV", 2.5/16, S("MV Cable (digiline)"), "_digi", {
+		digiline = {
+			wire = {
+				rules = {
+					{x = 1, y = 0, z = 0},
+					{x =-1, y = 0, z = 0},
+					{x = 0, y = 1, z = 0},
+					{x = 0, y =-1, z = 0},
+					{x = 0, y = 0, z = 1},
+					{x = 0, y = 0, z =-1}
+				}
+			}
+		}
+	})
+end

mods/technic_plus/technic/machines/MV/centrifuge.lua

@@ -0,0 +1,16 @@
+minetest.register_craft({
+	output = "technic:mv_centrifuge",
+	recipe = {
+		{"basic_materials:motor",          "technic:copper_plate",   "technic:diamond_drill_head"},
+		{"technic:copper_plate",   "technic:machine_casing", "technic:copper_plate"      },
+		{"pipeworks:one_way_tube", "technic:mv_cable",       "pipeworks:mese_filter"     },
+	}
+})
+
+technic.register_centrifuge({
+	tier = "MV",
+	demand = { 8000, 7000, 6000 },
+	speed = 2,
+	upgrade = 1,
+	tube = 1,
+})

mods/technic_plus/technic/machines/MV/compressor.lua

@@ -0,0 +1,12 @@
+-- MV compressor
+
+minetest.register_craft({
+	output = 'technic:mv_compressor',
+	recipe = {
+		{'technic:stainless_steel_ingot', 'technic:lv_compressor',  'technic:stainless_steel_ingot'},
+		{'pipeworks:tube_1',              'technic:mv_transformer', 'pipeworks:tube_1'},
+		{'technic:stainless_steel_ingot', 'technic:mv_cable',       'technic:stainless_steel_ingot'},
+	}
+})
+
+technic.register_compressor({tier = "MV", demand = {800, 600, 400}, speed = 2, upgrade = 1, tube = 1})

mods/technic_plus/technic/machines/MV/electric_furnace.lua

@@ -0,0 +1,18 @@
+-- MV Electric Furnace
+-- This is a faster version of the stone furnace which runs on EUs
+-- In addition to this it can be upgraded with microcontrollers and batteries
+-- This new version uses the batteries to lower the power consumption of the machine
+-- Also in addition this furnace can be attached to the pipe system from the pipeworks mod.
+
+-- FIXME: kpoppel I'd like to introduce an induction heating element here also
+minetest.register_craft({
+	output = 'technic:mv_electric_furnace',
+	recipe = {
+		{'technic:stainless_steel_ingot', 'technic:lv_electric_furnace', 'technic:stainless_steel_ingot'},
+		{'pipeworks:tube_1',              'technic:mv_transformer',      'pipeworks:tube_1'},
+		{'technic:stainless_steel_ingot', 'technic:mv_cable',            'technic:stainless_steel_ingot'},
+	}
+})
+
+technic.register_electric_furnace({tier="MV", upgrade=1, tube=1, demand={2000, 1000, 500}, speed=4})
+

mods/technic_plus/technic/machines/MV/extractor.lua

@@ -0,0 +1,12 @@
+-- MV extractor
+
+minetest.register_craft({
+	output = 'technic:mv_extractor',
+	recipe = {
+		{'technic:stainless_steel_ingot', 'technic:lv_extractor',   'technic:stainless_steel_ingot'},
+		{'pipeworks:tube_1',              'technic:mv_transformer', 'pipeworks:tube_1'},
+		{'technic:stainless_steel_ingot', 'technic:mv_cable',       'technic:stainless_steel_ingot'},
+	}
+})
+
+technic.register_extractor({tier = "MV", demand = {800, 600, 400}, speed = 2, upgrade = 1, tube = 1})

mods/technic_plus/technic/machines/MV/freezer.lua

@@ -0,0 +1,12 @@
+-- MV freezer
+
+minetest.register_craft({
+	output = 'technic:mv_freezer',
+	recipe = {
+		{'technic:stainless_steel_ingot', 'technic:motor',          'technic:stainless_steel_ingot'},
+		{'pipeworks:pipe_1_empty',        'technic:mv_transformer', 'pipeworks:pipe_1_empty'},
+		{'technic:stainless_steel_ingot', 'technic:mv_cable',       'technic:stainless_steel_ingot'},
+	}
+})
+
+technic.register_freezer({tier = "MV", demand = {800, 600, 400}, speed = 0.5, upgrade = 1, tube = 1})

mods/technic_plus/technic/machines/MV/generator.lua

@@ -0,0 +1,13 @@
+minetest.register_alias("generator_mv", "technic:generator_mv")
+
+minetest.register_craft({
+	output = 'technic:mv_generator',
+	recipe = {
+		{'technic:stainless_steel_ingot', 'technic:lv_generator',   'technic:stainless_steel_ingot'},
+		{'pipeworks:tube_1',              'technic:mv_transformer', 'pipeworks:tube_1'},
+		{'technic:stainless_steel_ingot', 'technic:mv_cable',       'technic:stainless_steel_ingot'},
+	}
+})
+
+technic.register_generator({tier="MV", tube=1, supply=600})
+

mods/technic_plus/technic/machines/MV/grinder.lua

@@ -0,0 +1,13 @@
+-- MV grinder
+
+minetest.register_craft({
+	output = 'technic:mv_grinder',
+	recipe = {
+		{'technic:stainless_steel_ingot', 'technic:lv_grinder',     'technic:stainless_steel_ingot'},
+		{'pipeworks:tube_1',              'technic:mv_transformer', 'pipeworks:tube_1'},
+		{'technic:stainless_steel_ingot', 'technic:mv_cable',       'technic:stainless_steel_ingot'},
+	}
+})
+
+technic.register_grinder({tier="MV", demand={600, 450, 300}, speed=2, upgrade=1, tube=1})
+

mods/technic_plus/technic/machines/MV/hydro_turbine.lua

@@ -0,0 +1,105 @@
+-- A Hydro Turbine produces MV EUs by exploiting flowing water across it
+-- It is a MV EU supplier and fairly high yield (max 1800EUs)
+
+local S = technic.getter
+
+local cable_entry = "^technic_cable_connection_overlay.png"
+
+minetest.register_alias("hydro_turbine", "technic:hydro_turbine")
+
+minetest.register_craft({
+	output = 'technic:hydro_turbine',
+	recipe = {
+		{'technic:stainless_steel_ingot', 'technic:water_mill', 'technic:stainless_steel_ingot'},
+		{'technic:water_mill', 'technic:mv_transformer', 'technic:water_mill'},
+		{'technic:stainless_steel_ingot', 'technic:mv_cable', 'technic:stainless_steel_ingot'},
+	}
+})
+
+local function get_water_flow(pos)
+	local node = minetest.get_node(pos)
+	if minetest.get_item_group(node.name, "water") == 3 then
+		return node.param2 -- returns approx. water flow, if any
+	end
+	return 0
+end
+
+---
+-- 10 times better than LV hydro because of 2 extra water mills and 4 stainless steel, a transformer and whatnot ;P.
+-- Man hydro turbines are tough and long lasting. So, give it some value :)
+local run = function(pos, node)
+	local meta             = minetest.get_meta(pos)
+	local water_flow       = 0
+	local production_level
+	local eu_supply
+	local max_output       = 40 * 45 -- Generates 1800EU/s
+
+	local positions = {
+		{x=pos.x+1, y=pos.y, z=pos.z},
+		{x=pos.x-1, y=pos.y, z=pos.z},
+		{x=pos.x,   y=pos.y, z=pos.z+1},
+		{x=pos.x,   y=pos.y, z=pos.z-1},
+	}
+
+	for _, p in pairs(positions) do
+		water_flow = water_flow + get_water_flow(p)
+	end
+
+	eu_supply = math.min(40 * water_flow, max_output)
+	production_level = math.floor(100 * eu_supply / max_output)
+
+	meta:set_int("MV_EU_supply", eu_supply)
+
+	meta:set_string("infotext",
+	S("Hydro %s Generator"):format("MV").." ("..production_level.."%)")
+	if production_level > 0 and
+		minetest.get_node(pos).name == "technic:hydro_turbine" then
+		technic.swap_node(pos, "technic:hydro_turbine_active")
+		meta:set_int("MV_EU_supply", 0)
+		return
+	end
+	if production_level == 0 then
+		technic.swap_node(pos, "technic:hydro_turbine")
+	end
+end
+
+minetest.register_node("technic:hydro_turbine", {
+	description = S("Hydro %s Generator"):format("MV"),
+	tiles = {
+		"technic_hydro_turbine_top.png",
+		"technic_machine_bottom.png"..cable_entry,
+		"technic_hydro_turbine_side.png",
+		"technic_hydro_turbine_side.png",
+		"technic_hydro_turbine_side.png",
+		"technic_hydro_turbine_side.png"
+	},
+	paramtype2 = "facedir",
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+	technic_machine=1, technic_mv=1},
+	legacy_facedir_simple = true,
+	sounds = default.node_sound_wood_defaults(),
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("Hydro %s Generator"):format("MV"))
+		meta:set_int("MV_EU_supply", 0)
+	end,
+	technic_run = run,
+})
+
+minetest.register_node("technic:hydro_turbine_active", {
+	description = S("Hydro %s Generator"):format("MV"),
+	tiles = {"technic_hydro_turbine_top_active.png", "technic_machine_bottom.png",
+			"technic_hydro_turbine_side.png", "technic_hydro_turbine_side.png",
+			"technic_hydro_turbine_side.png", "technic_hydro_turbine_side.png"},
+	paramtype2 = "facedir",
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+			technic_machine=1, technic_mv=1, not_in_creative_inventory=1},
+	legacy_facedir_simple = true,
+	sounds = default.node_sound_wood_defaults(),
+	drop = "technic:hydro_turbine",
+	technic_run = run,
+	technic_disabled_machine_name = "technic:hydro_turbine",
+})
+
+technic.register_machine("MV", "technic:hydro_turbine",        technic.producer)
+technic.register_machine("MV", "technic:hydro_turbine_active", technic.producer)

mods/technic_plus/technic/machines/MV/init.lua

@@ -0,0 +1,35 @@
+
+technic.register_tier("MV", "Medium Voltage")
+
+local path = technic.modpath.."/machines/MV"
+
+-- Wiring stuff
+dofile(path.."/cables.lua")
+dofile(path.."/battery_box.lua")
+
+-- Generators
+if technic.config:get_bool("enable_wind_mill") then
+	dofile(path.."/wind_mill.lua")
+end
+dofile(path.."/generator.lua")
+dofile(path.."/solar_array.lua")
+dofile(path.."/hydro_turbine.lua")
+
+-- Machines
+dofile(path.."/alloy_furnace.lua")
+dofile(path.."/electric_furnace.lua")
+dofile(path.."/grinder.lua")
+dofile(path.."/extractor.lua")
+dofile(path.."/compressor.lua")
+dofile(path.."/centrifuge.lua")
+
+dofile(path.."/tool_workshop.lua")
+
+dofile(path.."/freezer.lua")
+
+-- The power radiator supplies appliances with inductive coupled power:
+-- Lighting and associated textures is taken directly from VanessaE's homedecor and made electric.
+-- This is currently useless, slow, and mostly copied
+--dofile(path.."/power_radiator.lua")
+--dofile(path.."/lighting.lua")
+

mods/technic_plus/technic/machines/MV/lighting.lua

@@ -0,0 +1,575 @@
+-- NOTE: The code is takes directly from VanessaE's homedecor mod.
+-- I just made it the lights into indictive appliances for this mod.
+
+-- This file supplies electric powered glowlights
+
+-- Boilerplate to support localized strings if intllib mod is installed.
+local S
+if (minetest.get_modpath("intllib")) then
+	dofile(minetest.get_modpath("intllib").."/intllib.lua")
+	S = intllib.Getter(minetest.get_current_modname())
+else
+	S = function (s) return s end
+end
+
+local function technic_homedecor_node_is_owned(pos, placer)
+        local ownername = false
+        if type(isprotect) == "function" then -- glomie's protection mod
+                if not isprotect(5, pos, placer) then
+                        ownername = S("someone")
+                end
+        elseif type(protector) == "table" and type(protector.can_dig) == "function" then -- Zeg9's protection mod
+                if not protector.can_dig(5, pos, placer) then
+                        ownername = S("someone")
+                end
+        end
+
+        if ownername ~= false then
+                minetest.chat_send_player(placer:get_player_name(), S("Sorry, %s owns that spot."):format(ownername) )
+                return true
+        else
+                return false
+        end
+end
+
+local dirs2 = {9,  18,  7, 12}
+
+local technic_homedecor_rotate_and_place = function(itemstack, placer, pointed_thing)
+	if not technic_homedecor_node_is_owned(pointed_thing.under, placer)
+	   and not technic_homedecor_node_is_owned(pointed_thing.above, placer) then
+		local node = minetest.get_node(pointed_thing.under)
+		if not minetest.registered_nodes[node.name] or not minetest.registered_nodes[node.name].on_rightclick then
+
+			local above = pointed_thing.above
+			local under = pointed_thing.under
+			local pitch = placer:get_look_pitch()
+			local pname = minetest.get_node(under).name
+			local fdir = minetest.dir_to_facedir(placer:get_look_dir())
+			local wield_name = itemstack:get_name()
+
+			if not minetest.registered_nodes[pname]
+			    or not minetest.registered_nodes[pname].on_rightclick then
+
+				local iswall = (above.x ~= under.x) or (above.z ~= under.z)
+				local isceiling = (above.x == under.x) and (above.z == under.z) and (pitch > 0)
+				local pos1 = above
+
+				if minetest.registered_nodes[pname]["buildable_to"] then
+					pos1 = under
+					iswall = false
+				end
+
+				if not minetest.registered_nodes[minetest.get_node(pos1).name]["buildable_to"] then return end
+
+				if iswall then
+					minetest.add_node(pos1, {name = wield_name, param2 = dirs2[fdir+1] }) -- place wall variant
+				elseif isceiling then
+					minetest.add_node(pos1, {name = wield_name, param2 = 20 }) -- place upside down variant
+				else
+					minetest.add_node(pos1, {name = wield_name, param2 = 0 }) -- place right side up
+				end
+
+				if not homedecor_expect_infinite_stacks then
+					itemstack:take_item()
+					return itemstack
+				end
+			end
+		else
+			minetest.registered_nodes[node.name].on_rightclick(pointed_thing.under, node, placer, itemstack)
+		end
+	end
+end
+
+-- Yellow -- Half node
+minetest.register_node('technic:homedecor_glowlight_half_yellow', {
+	description = S("Yellow Glowlight (thick)"),
+	drawtype = "nodebox",
+	tiles = {
+		'technic_homedecor_glowlight_yellow_tb.png',
+		'technic_homedecor_glowlight_yellow_tb.png',
+		'technic_homedecor_glowlight_thick_yellow_sides.png',
+		'technic_homedecor_glowlight_thick_yellow_sides.png',
+		'technic_homedecor_glowlight_thick_yellow_sides.png',
+		'technic_homedecor_glowlight_thick_yellow_sides.png'
+	},
+        selection_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, 0, 0.5 }
+        },
+        node_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, 0, 0.5 }
+        },
+
+	sunlight_propagates = false,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	walkable = true,
+	sounds = default.node_sound_wood_defaults(),
+
+	groups = { snappy = 3 },
+	on_place = function(itemstack, placer, pointed_thing)
+		technic_homedecor_rotate_and_place(itemstack, placer, pointed_thing)
+		return itemstack
+	     end,
+	on_construct = function(pos)
+			  technic.inductive_on_construct(pos, 100, "Yellow Glowlight (thick)")
+		       end,
+	on_punch = function(pos, node, puncher)
+		      technic.inductive_on_punch_off(pos, 100, "technic:homedecor_glowlight_half_yellow_active")
+		   end
+})
+
+minetest.register_node('technic:homedecor_glowlight_half_yellow_active', {
+	description = S("Yellow Glowlight (thick)"),
+	drawtype = "nodebox",
+	tiles = {
+		'technic_homedecor_glowlight_yellow_tb.png',
+		'technic_homedecor_glowlight_yellow_tb.png',
+		'technic_homedecor_glowlight_thick_yellow_sides.png',
+		'technic_homedecor_glowlight_thick_yellow_sides.png',
+		'technic_homedecor_glowlight_thick_yellow_sides.png',
+		'technic_homedecor_glowlight_thick_yellow_sides.png'
+	},
+        selection_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, 0, 0.5 }
+        },
+        node_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, 0, 0.5 }
+        },
+
+	sunlight_propagates = false,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	walkable = true,
+	light_source = minetest.LIGHT_MAX,
+	sounds = default.node_sound_wood_defaults(),
+
+	groups = { snappy = 3, not_in_creative_inventory=1},
+	drop="technic:homedecor_glowlight_half_yellow",
+	on_place = function(itemstack, placer, pointed_thing)
+		technic_homedecor_rotate_and_place(itemstack, placer, pointed_thing)
+		return itemstack
+	     end,
+	on_construct = function(pos)
+			  technic.inductive_on_construct(pos, 100, "Yellow Glowlight (thick)")
+		       end,
+	on_punch = function(pos, node, puncher)
+		      technic.inductive_on_punch_on(pos, 0, "technic:homedecor_glowlight_half_yellow")
+		   end
+})
+
+-- Yellow -- Quarter node
+minetest.register_node('technic:homedecor_glowlight_quarter_yellow', {
+	description = S("Yellow Glowlight (thin)"),
+	drawtype = "nodebox",
+	tiles = {
+		'technic_homedecor_glowlight_yellow_tb.png',
+		'technic_homedecor_glowlight_yellow_tb.png',
+		'technic_homedecor_glowlight_thin_yellow_sides.png',
+		'technic_homedecor_glowlight_thin_yellow_sides.png',
+		'technic_homedecor_glowlight_thin_yellow_sides.png',
+		'technic_homedecor_glowlight_thin_yellow_sides.png'
+	},
+        selection_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, -0.25, 0.5 }
+        },
+        node_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, -0.25, 0.5 }
+        },
+
+	sunlight_propagates = false,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	walkable = true,
+	sounds = default.node_sound_wood_defaults(),
+
+	groups = { snappy = 3 },
+	on_place = function(itemstack, placer, pointed_thing)
+		technic_homedecor_rotate_and_place(itemstack, placer, pointed_thing)
+		return itemstack
+	     end,
+	on_construct = function(pos)
+			  technic.inductive_on_construct(pos, 100, "Yellow Glowlight (thin)")
+		       end,
+	on_punch = function(pos, node, puncher)
+		      technic.inductive_on_punch_off(pos, 100, "technic:homedecor_glowlight_quarter_yellow_active")
+		   end
+})
+
+minetest.register_node('technic:homedecor_glowlight_quarter_yellow_active', {
+	description = S("Yellow Glowlight (thin)"),
+	drawtype = "nodebox",
+	tiles = {
+		'technic_homedecor_glowlight_yellow_tb.png',
+		'technic_homedecor_glowlight_yellow_tb.png',
+		'technic_homedecor_glowlight_thin_yellow_sides.png',
+		'technic_homedecor_glowlight_thin_yellow_sides.png',
+		'technic_homedecor_glowlight_thin_yellow_sides.png',
+		'technic_homedecor_glowlight_thin_yellow_sides.png'
+	},
+        selection_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, -0.25, 0.5 }
+        },
+        node_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, -0.25, 0.5 }
+        },
+
+	sunlight_propagates = false,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	walkable = true,
+	light_source = minetest.LIGHT_MAX-1,
+	sounds = default.node_sound_wood_defaults(),
+
+	groups = { snappy = 3, not_in_creative_inventory=1},
+	drop="technic:homedecor_glowlight_quarter_yellow",
+	on_place = function(itemstack, placer, pointed_thing)
+		technic_homedecor_rotate_and_place(itemstack, placer, pointed_thing)
+		return itemstack
+	     end,
+	on_construct = function(pos)
+			  technic.inductive_on_construct(pos, 100, "Yellow Glowlight (thin)")
+		       end,
+	on_punch = function(pos, node, puncher)
+		      technic.inductive_on_punch_on(pos, 0, "technic:homedecor_glowlight_quarter_yellow")
+		   end
+})
+
+
+-- White -- half node
+minetest.register_node('technic:homedecor_glowlight_half_white', {
+	description = S("White Glowlight (thick)"),
+	drawtype = "nodebox",
+	tiles = {
+		'technic_homedecor_glowlight_white_tb.png',
+		'technic_homedecor_glowlight_white_tb.png',
+		'technic_homedecor_glowlight_thick_white_sides.png',
+		'technic_homedecor_glowlight_thick_white_sides.png',
+		'technic_homedecor_glowlight_thick_white_sides.png',
+		'technic_homedecor_glowlight_thick_white_sides.png'
+	},
+        selection_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, 0, 0.5 }
+        },
+        node_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, 0, 0.5 }
+        },
+
+	sunlight_propagates = false,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	walkable = true,
+	sounds = default.node_sound_wood_defaults(),
+
+	groups = { snappy = 3 },
+	on_place = function(itemstack, placer, pointed_thing)
+		technic_homedecor_rotate_and_place(itemstack, placer, pointed_thing)
+		return itemstack
+	     end,
+	on_construct = function(pos)
+			  technic.inductive_on_construct(pos, 100, "White Glowlight (thick)")
+		       end,
+	on_punch = function(pos, node, puncher)
+		      technic.inductive_on_punch_off(pos, 100, "technic:homedecor_glowlight_half_white_active")
+		   end
+})
+
+minetest.register_node('technic:homedecor_glowlight_half_white_active', {
+	description = S("White Glowlight (thick)"),
+	drawtype = "nodebox",
+	tiles = {
+		'technic_homedecor_glowlight_white_tb.png',
+		'technic_homedecor_glowlight_white_tb.png',
+		'technic_homedecor_glowlight_thick_white_sides.png',
+		'technic_homedecor_glowlight_thick_white_sides.png',
+		'technic_homedecor_glowlight_thick_white_sides.png',
+		'technic_homedecor_glowlight_thick_white_sides.png'
+	},
+        selection_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, 0, 0.5 }
+        },
+        node_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, 0, 0.5 }
+        },
+
+	sunlight_propagates = false,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	walkable = true,
+	light_source = minetest.LIGHT_MAX,
+	sounds = default.node_sound_wood_defaults(),
+
+	groups = { snappy = 3, not_in_creative_inventory=1},
+	drop="technic:homedecor_glowlight_half_white",
+	on_place = function(itemstack, placer, pointed_thing)
+		technic_homedecor_rotate_and_place(itemstack, placer, pointed_thing)
+		return itemstack
+	     end,
+	on_construct = function(pos)
+			  technic.inductive_on_construct(pos, 100, "White Glowlight (thick)")
+		       end,
+	on_punch = function(pos, node, puncher)
+		      technic.inductive_on_punch_on(pos, 0, "technic:homedecor_glowlight_half_white")
+		   end
+})
+
+-- White -- Quarter node
+minetest.register_node('technic:homedecor_glowlight_quarter_white', {
+	description = S("White Glowlight (thin)"),
+	drawtype = "nodebox",
+	tiles = {
+		'technic_homedecor_glowlight_white_tb.png',
+		'technic_homedecor_glowlight_white_tb.png',
+		'technic_homedecor_glowlight_thin_white_sides.png',
+		'technic_homedecor_glowlight_thin_white_sides.png',
+		'technic_homedecor_glowlight_thin_white_sides.png',
+		'technic_homedecor_glowlight_thin_white_sides.png'
+	},
+        selection_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, -0.25, 0.5 }
+        },
+        node_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, -0.25, 0.5 }
+        },
+
+	sunlight_propagates = false,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	walkable = true,
+	sounds = default.node_sound_wood_defaults(),
+
+	groups = { snappy = 3 },
+	on_place = function(itemstack, placer, pointed_thing)
+		technic_homedecor_rotate_and_place(itemstack, placer, pointed_thing)
+		return itemstack
+	     end,
+	on_construct = function(pos)
+			  technic.inductive_on_construct(pos, 100, "White Glowlight (thin)")
+		       end,
+	on_punch = function(pos, node, puncher)
+		      technic.inductive_on_punch_off(pos, 100, "technic:homedecor_glowlight_quarter_white_active")
+		   end
+})
+
+minetest.register_node('technic:homedecor_glowlight_quarter_white_active', {
+	description = S("White Glowlight (thin)"),
+	drawtype = "nodebox",
+	tiles = {
+		'technic_homedecor_glowlight_white_tb.png',
+		'technic_homedecor_glowlight_white_tb.png',
+		'technic_homedecor_glowlight_thin_white_sides.png',
+		'technic_homedecor_glowlight_thin_white_sides.png',
+		'technic_homedecor_glowlight_thin_white_sides.png',
+		'technic_homedecor_glowlight_thin_white_sides.png'
+	},
+        selection_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, -0.25, 0.5 }
+        },
+        node_box = {
+                type = "fixed",
+                fixed = { -0.5, -0.5, -0.5, 0.5, -0.25, 0.5 }
+        },
+
+	sunlight_propagates = false,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	walkable = true,
+	light_source = minetest.LIGHT_MAX-1,
+	sounds = default.node_sound_wood_defaults(),
+
+	groups = { snappy = 3, not_in_creative_inventory=1},
+	drop="technic:homedecor_glowlight_quarter_white",
+	on_place = function(itemstack, placer, pointed_thing)
+		technic_homedecor_rotate_and_place(itemstack, placer, pointed_thing)
+		return itemstack
+	     end,
+	on_construct = function(pos)
+			  technic.inductive_on_construct(pos, 100, "White Glowlight (thin)")
+		       end,
+	on_punch = function(pos, node, puncher)
+		      technic.inductive_on_punch_on(pos, 0, "technic:homedecor_glowlight_quarter_white")
+		   end
+})
+
+-- Glowlight "cubes" - yellow
+minetest.register_node('technic:homedecor_glowlight_small_cube_yellow', {
+	description = S("Yellow Glowlight (small cube)"),
+	drawtype = "nodebox",
+	tiles = {
+		'technic_homedecor_glowlight_cube_yellow_tb.png',
+		'technic_homedecor_glowlight_cube_yellow_tb.png',
+		'technic_homedecor_glowlight_cube_yellow_sides.png',
+		'technic_homedecor_glowlight_cube_yellow_sides.png',
+		'technic_homedecor_glowlight_cube_yellow_sides.png',
+		'technic_homedecor_glowlight_cube_yellow_sides.png'
+	},
+        selection_box = {
+                type = "fixed",
+                fixed = { -0.25, -0.5, -0.25, 0.25, 0, 0.25 }
+        },
+        node_box = {
+                type = "fixed",
+                fixed = { -0.25, -0.5, -0.25, 0.25, 0, 0.25 }
+        },
+
+	sunlight_propagates = false,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	walkable = true,
+	sounds = default.node_sound_wood_defaults(),
+
+	groups = { snappy = 3 },
+	on_place = function(itemstack, placer, pointed_thing)
+		technic_homedecor_rotate_and_place(itemstack, placer, pointed_thing)
+		return itemstack
+	     end,
+	on_construct = function(pos)
+			  technic.inductive_on_construct(pos, 50, "Yellow Glowlight (small cube)")
+		       end,
+	on_punch = function(pos, node, puncher)
+		      technic.inductive_on_punch_off(pos, 50, "technic:homedecor_glowlight_small_cube_yellow_active")
+		   end
+})
+
+minetest.register_node('technic:homedecor_glowlight_small_cube_yellow_active', {
+	description = S("Yellow Glowlight (small cube)"),
+	drawtype = "nodebox",
+	tiles = {
+		'technic_homedecor_glowlight_cube_yellow_tb.png',
+		'technic_homedecor_glowlight_cube_yellow_tb.png',
+		'technic_homedecor_glowlight_cube_yellow_sides.png',
+		'technic_homedecor_glowlight_cube_yellow_sides.png',
+		'technic_homedecor_glowlight_cube_yellow_sides.png',
+		'technic_homedecor_glowlight_cube_yellow_sides.png'
+	},
+        selection_box = {
+                type = "fixed",
+                fixed = { -0.25, -0.5, -0.25, 0.25, 0, 0.25 }
+        },
+        node_box = {
+                type = "fixed",
+                fixed = { -0.25, -0.5, -0.25, 0.25, 0, 0.25 }
+        },
+
+	sunlight_propagates = false,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	walkable = true,
+	light_source = minetest.LIGHT_MAX-1,
+	sounds = default.node_sound_wood_defaults(),
+
+	groups = { snappy = 3, not_in_creative_inventory=1},
+	drop="technic:homedecor_glowlight_small_cube_yellow",
+	on_place = function(itemstack, placer, pointed_thing)
+		technic_homedecor_rotate_and_place(itemstack, placer, pointed_thing)
+		return itemstack
+	     end,
+	on_construct = function(pos)
+			  technic.inductive_on_construct(pos, 50, "Yellow Glowlight (small cube)")
+		       end,
+	on_punch = function(pos, node, puncher)
+		      technic.inductive_on_punch_on(pos, 0, "technic:homedecor_glowlight_small_cube_yellow")
+		   end
+})
+
+-- Glowlight "cubes" - white
+minetest.register_node('technic:homedecor_glowlight_small_cube_white', {
+	description = S("White Glowlight (small cube)"),
+	drawtype = "nodebox",
+	tiles = {
+		'technic_homedecor_glowlight_cube_white_tb.png',
+		'technic_homedecor_glowlight_cube_white_tb.png',
+		'technic_homedecor_glowlight_cube_white_sides.png',
+		'technic_homedecor_glowlight_cube_white_sides.png',
+		'technic_homedecor_glowlight_cube_white_sides.png',
+		'technic_homedecor_glowlight_cube_white_sides.png'
+	},
+        selection_box = {
+                type = "fixed",
+                fixed = { -0.25, -0.5, -0.25, 0.25, 0, 0.25 }
+        },
+        node_box = {
+                type = "fixed",
+                fixed = { -0.25, -0.5, -0.25, 0.25, 0, 0.25 }
+        },
+
+	sunlight_propagates = false,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	walkable = true,
+	sounds = default.node_sound_wood_defaults(),
+
+	groups = { snappy = 3 },
+	on_place = function(itemstack, placer, pointed_thing)
+		technic_homedecor_rotate_and_place(itemstack, placer, pointed_thing)
+		return itemstack
+	     end,
+	on_construct = function(pos)
+			  technic.inductive_on_construct(pos, 50, "White Glowlight (small cube)")
+		       end,
+	on_punch = function(pos, node, puncher)
+		      technic.inductive_on_punch_off(pos, 50, "technic:homedecor_glowlight_small_cube_white_active")
+		   end
+})
+
+minetest.register_node('technic:homedecor_glowlight_small_cube_white_active', {
+	description = S("White Glowlight (small cube)"),
+	drawtype = "nodebox",
+	tiles = {
+		'technic_homedecor_glowlight_cube_white_tb.png',
+		'technic_homedecor_glowlight_cube_white_tb.png',
+		'technic_homedecor_glowlight_cube_white_sides.png',
+		'technic_homedecor_glowlight_cube_white_sides.png',
+		'technic_homedecor_glowlight_cube_white_sides.png',
+		'technic_homedecor_glowlight_cube_white_sides.png'
+	},
+        selection_box = {
+                type = "fixed",
+                fixed = { -0.25, -0.5, -0.25, 0.25, 0, 0.25 }
+        },
+        node_box = {
+                type = "fixed",
+                fixed = { -0.25, -0.5, -0.25, 0.25, 0, 0.25 }
+        },
+
+	sunlight_propagates = false,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	walkable = true,
+	light_source = minetest.LIGHT_MAX-1,
+	sounds = default.node_sound_wood_defaults(),
+
+	groups = { snappy = 3, not_in_creative_inventory=1},
+	drop="technic:homedecor_glowlight_small_cube_white",
+	on_place = function(itemstack, placer, pointed_thing)
+		technic_homedecor_rotate_and_place(itemstack, placer, pointed_thing)
+		return itemstack
+	     end,
+	on_construct = function(pos)
+			  technic.inductive_on_construct(pos, 50, "White Glowlight (small cube)")
+		       end,
+	on_punch = function(pos, node, puncher)
+		      technic.inductive_on_punch_on(pos, 0, "technic:homedecor_glowlight_small_cube_white")
+		   end
+})
+
+technic.register_inductive_machine("technic:homedecor_glowlight_half_yellow")
+technic.register_inductive_machine("technic:homedecor_glowlight_half_white")
+technic.register_inductive_machine("technic:homedecor_glowlight_quarter_yellow")
+technic.register_inductive_machine("technic:homedecor_glowlight_quarter_white")
+technic.register_inductive_machine("technic:homedecor_glowlight_small_cube_yellow")
+technic.register_inductive_machine("technic:homedecor_glowlight_small_cube_white")

mods/technic_plus/technic/machines/MV/power_radiator.lua

@@ -0,0 +1,220 @@
+-- The power radiator fuctions like an inductive charger
+-- only better in the game setting.
+-- The purpose is to allow small appliances to receive power
+-- without the overhead of the wiring needed for larger machines.
+--
+-- The power radiator will consume power corresponding to the
+-- sum(power rating of the attached appliances)/0.06
+-- Using inductive power transfer is very inefficient so this is
+-- set to the factor 0.06.
+--
+-- Punching the radiator will toggle the power state of all attached appliances.
+
+local power_radius = 12
+
+
+minetest.register_craft({
+	output = 'technic:power_radiator 1',
+	recipe = {
+		{'technic:stainless_steel_ingot', 'technic:mv_transformer', 'technic:stainless_steel_ingot'},
+		{'technic:copper_coil',           'technic:machine_casing', 'technic:copper_coil'},
+		{'technic:rubber',                'technic:mv_cable',       'technic:rubber'},
+	}
+})
+
+------------------------------------------------------------------
+-- API for inductive powered nodes:
+-- Use the functions below to set the corresponding callbacks
+-- Also two nodes are needed: The inactive and the active one. The active must be called <name>_active .
+------------------------------------------------------------------
+-- Register a new appliance using this function
+
+technic.inductive_nodes = {}
+technic.register_inductive_machine = function(name)
+	table.insert(technic.inductive_nodes, name)
+	table.insert(technic.inductive_nodes, name.."_active")
+end
+
+-- Appliances:
+--  has_supply: pos of supply node if the appliance has a power radiator near with sufficient power for the demand
+--  EU_demand: The power demand of the device.
+--  EU_charge: Actual use. set to EU_demand if active==1
+--  active: set to 1 if the device is on
+technic.inductive_on_construct = function(pos, eu_demand, infotext)
+	local meta = minetest.get_meta(pos)
+	meta:set_string("infotext", infotext)
+	meta:set_int("technic_inductive_power_machine", 1)
+	meta:set_int("EU_demand", eu_demand)     -- The power demand of this appliance
+	meta:set_int("EU_charge", 0)       -- The actual power draw of this appliance
+	meta:set_string("has_supply", "") -- Register whether we are powered or not. For use with several radiators.
+	meta:set_int("active", 0)    -- If the appliance can be turned on and off by using it use this.
+end
+
+technic.inductive_on_punch_off = function(pos, eu_charge, swapnode)
+	local meta = minetest.get_meta(pos)
+	if meta:get_string("has_supply") ~= "" then
+		technic.swap_node(pos, swapnode)
+		meta:set_int("active", 1)
+		meta:set_int("EU_charge",eu_charge)
+		--print("-----------")
+		--print("Turn on:")
+		--print("EU_charge: "..meta:get_int("EU_charge"))
+		--print("has_supply: "..meta:get_string("has_supply"))
+		--print("<----------->")
+	end
+end
+
+technic.inductive_on_punch_on = function(pos, eu_charge, swapnode)
+	local meta = minetest.get_meta(pos)
+	technic.swap_node(pos, swapnode)
+	meta:set_int("active", 0)
+	meta:set_int("EU_charge",eu_charge)
+	--print("-----------")
+	--print("Turn off:")
+	--print("EU_charge: "..meta:get_int("EU_charge"))
+	--print("has_supply: "..meta:get_string("has_supply"))
+	--print("<---------->")
+end
+
+local shutdown_inductive_appliances = function(pos)
+	-- The supply radius
+	local rad = power_radius
+	-- If the radiator is removed. turn off all appliances in region
+	-- If another radiator is near it will turn on the appliances again
+	local positions = minetest.find_nodes_in_area(
+		{x=pos.x-rad, y=pos.y-rad, z=pos.z-rad},
+		{x=pos.x+rad, y=pos.y+rad, z=pos.z+rad},
+		technic.inductive_nodes)
+	for _, pos1 in pairs(positions) do
+		local meta1 = minetest.get_meta(pos1)
+		-- If the appliance is belonging to this node
+		if meta1:get_string("has_supply") == pos.x..pos.y..pos.z then
+			local nodename = minetest.get_node(pos1).name
+			-- Swap the node and make sure it is off and unpowered
+			if string.sub(nodename, -7) == "_active" then
+				technic.swap_node(pos1, string.sub(nodename, 1, -8))
+				meta1:set_int("active", 0)
+				meta1:set_int("EU_charge", 0)
+			end
+			meta1:set_string("has_supply", "")
+		end
+	end
+end
+
+local toggle_on_off_inductive_appliances = function(pos, node, puncher)
+	if pos == nil then return end
+	-- The supply radius
+	local rad = power_radius
+	local positions = minetest.find_nodes_in_area(
+		{x=pos.x-rad, y=pos.y-rad, z=pos.z-rad},
+		{x=pos.x+rad, y=pos.y+rad, z=pos.z+rad},
+		technic.inductive_nodes)
+	for _, pos1 in pairs(positions) do
+		local meta1 = minetest.get_meta(pos1)
+		if meta1:get_string("has_supply") == pos.x..pos.y..pos.z then
+			minetest.punch_node(pos1)
+		end
+	end
+end
+
+minetest.register_node("technic:power_radiator", {
+	description = "MV Power Radiator",
+	tiles  = {"technic_lv_cable.png", "technic_lv_cable.png", "technic_lv_cable.png",
+	          "technic_lv_cable.png", "technic_lv_cable.png", "technic_lv_cable.png"},
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2},
+	sounds = default.node_sound_wood_defaults(),
+	drawtype = "nodebox",
+	paramtype = "light",
+	is_ground_content = true,
+	node_box = {
+		type = "fixed",
+		fixed = {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
+	},
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_int("MV_EU_demand",1)               -- Demand on the primary side when idle
+		meta:set_int("connected_EU_demand",0)        -- Potential demand of connected appliances
+		meta:set_string("infotext", "MV Power Radiator")
+	end,
+	on_dig = function(pos, node, digger)
+		shutdown_inductive_appliances(pos)
+		return minetest.node_dig(pos, node, digger)
+	end,
+	on_punch = function(pos, node, puncher)
+		toggle_on_off_inductive_appliances(pos, node, puncher)
+	end
+})
+
+minetest.register_abm({
+	label = "Machines: run power radiator",
+	nodenames = {"technic:power_radiator"},
+	interval   = 1,
+	chance     = 1,
+	action = function(pos, node, active_object_count, active_object_count_wider)
+		local meta             = minetest.get_meta(pos)
+		local eu_input  = meta:get_int("MV_EU_input")
+		local eu_demand = meta:get_int("MV_EU_demand")
+
+		-- Power off automatically if no longer connected to a switching station
+		technic.switching_station_timeout_count(pos, "MV")
+
+		if eu_input == 0 then
+			-- No power
+			meta:set_string("infotext", "MV Power Radiator is unpowered");
+			-- meta:set_int("active", 1) -- used for setting textures someday maybe
+			shutdown_inductive_appliances(pos)
+			meta:set_int("connected_EU_demand", 0)
+			meta:set_int("MV_EU_demand",1)
+		elseif eu_input == eu_demand then
+			-- Powered and ready
+
+			-- The maximum EU sourcing a single radiator can provide.
+			local max_charge          = 30000 -- == the max EU demand of the radiator
+			local connected_EU_demand = meta:get_int("connected_EU_demand")
+
+			-- Efficiency factor
+			local eff_factor = 0.06
+			-- The supply radius
+			local rad = power_radius
+
+			local used_charge      = 0
+
+			-- Index all nodes within supply range
+			local positions = minetest.find_nodes_in_area(
+				{x=pos.x-rad, y=pos.y-rad, z=pos.z-rad},
+				{x=pos.x+rad, y=pos.y+rad, z=pos.z+rad},
+				technic.inductive_nodes)
+			for _, pos1 in pairs(positions) do
+				local meta1 = minetest.get_meta(pos1)
+				-- If not supplied see if this node can handle it.
+				if meta1:get_string("has_supply") == "" then
+					-- if demand surpasses the capacity of this node, don't bother adding it.
+					local app_eu_demand = math.floor(meta1:get_int("EU_demand") / eff_factor)
+					if connected_EU_demand + app_eu_demand <= max_charge then
+						-- We can power the appliance. Register, and spend power if it is on.
+						connected_EU_demand = connected_EU_demand + app_eu_demand
+
+						meta1:set_string("has_supply", pos.x..pos.y..pos.z)
+						--Always 0: used_charge = math.floor(used_charge + meta1:get_int("EU_charge") / eff_factor)
+					end
+				elseif meta1:get_string("has_supply") == pos.x..pos.y..pos.z then
+					-- The appliance has power from this node. Spend power if it is on.
+					used_charge = used_charge + math.floor(meta1:get_int("EU_charge") / eff_factor)
+				end
+				meta:set_string("infotext", "MV Power Radiator is powered ("
+					..math.floor(used_charge / max_charge * 100)
+					.."% of maximum power)");
+				if used_charge == 0 then
+					meta:set_int("MV_EU_demand", 1) -- Still idle
+				else
+					meta:set_int("MV_EU_demand", used_charge)
+				end
+			end
+			-- Save state
+			meta:set_int("connected_EU_demand", connected_EU_demand)
+		end
+	end,
+})
+
+technic.register_machine("MV", "technic:power_radiator", technic.receiver)
+

mods/technic_plus/technic/machines/MV/solar_array.lua

@@ -0,0 +1,14 @@
+
+minetest.register_craft({
+	output = 'technic:solar_array_mv 1',
+	recipe = {
+		{'technic:solar_array_lv',     'technic:solar_array_lv', 'technic:solar_array_lv'},
+		{'technic:carbon_steel_ingot', 'technic:mv_transformer', 'technic:carbon_steel_ingot'},
+		{'',                           'technic:mv_cable',       ''},
+	}
+})
+
+technic.register_solar_array({tier="MV", power=30})
+
+-- compatibility alias for upgrading from old versions of technic
+minetest.register_alias("technic:solar_panel_mv", "technic:solar_array_mv")

mods/technic_plus/technic/machines/MV/tool_workshop.lua

@@ -0,0 +1,126 @@
+-- Tool workshop
+-- This machine repairs tools.
+
+minetest.register_alias("tool_workshop", "technic:tool_workshop")
+
+local S = technic.getter
+
+local tube_entry = "^pipeworks_tube_connection_wooden.png"
+
+minetest.register_craft({
+	output = 'technic:tool_workshop',
+	recipe = {
+		{'group:wood',                         'default:diamond',        'group:wood'},
+		{'mesecons_pistons:piston_sticky_off', 'technic:machine_casing', 'technic:carbon_cloth'},
+		{'default:obsidian',                   'technic:mv_cable',       'default:obsidian'},
+	}
+})
+
+local workshop_demand = {5000, 3500, 2000}
+
+local workshop_formspec =
+	"size[8,9;]"..
+	"list[context;src;3,1;1,1;]"..
+	"label[0,0;"..S("%s Tool Workshop"):format("MV").."]"..
+	"list[context;upgrade1;1,3;1,1;]"..
+	"list[context;upgrade2;2,3;1,1;]"..
+	"label[1,4;"..S("Upgrade Slots").."]"..
+	"list[current_player;main;0,5;8,4;]"..
+	"listring[current_player;main]"..
+	"listring[context;src]"..
+	"listring[current_player;main]"..
+	"listring[context;upgrade1]"..
+	"listring[current_player;main]"..
+	"listring[context;upgrade2]"..
+	"listring[current_player;main]"
+
+local run = function(pos, node)
+	local meta         = minetest.get_meta(pos)
+	local inv          = meta:get_inventory()
+	local eu_input     = meta:get_int("MV_EU_input")
+	local machine_name = S("%s Tool Workshop"):format("MV")
+
+	-- Setup meta data if it does not exist.
+	if not eu_input then
+		meta:set_int("MV_EU_demand", workshop_demand[1])
+		meta:set_int("MV_EU_input", 0)
+		return
+	end
+
+	local EU_upgrade, tube_upgrade = technic.handle_machine_upgrades(meta)
+
+	local repairable = false
+	local srcstack = inv:get_stack("src", 1)
+	if not srcstack:is_empty() then
+		local itemdef = minetest.registered_items[srcstack:get_name()]
+		if itemdef and
+				(not itemdef.wear_represents or
+				itemdef.wear_represents == "mechanical_wear") and
+				srcstack:get_wear() ~= 0 then
+			repairable = true
+		end
+	end
+	technic.handle_machine_pipeworks(pos, tube_upgrade, function(pos2, x_velocity, z_velocity)
+		if not repairable then
+			technic.send_items(pos2, x_velocity, z_velocity, "src")
+		end
+	end)
+	if not repairable then
+		meta:set_string("infotext", S("%s Idle"):format(machine_name))
+		meta:set_int("MV_EU_demand", 0)
+		return
+	end
+
+	if eu_input < workshop_demand[EU_upgrade+1] then
+		meta:set_string("infotext", S("%s Unpowered"):format(machine_name))
+	elseif eu_input >= workshop_demand[EU_upgrade+1] then
+		meta:set_string("infotext", S("%s Active"):format(machine_name))
+		srcstack:add_wear(-1000)
+		inv:set_stack("src", 1, srcstack)
+	end
+	meta:set_int("MV_EU_demand", workshop_demand[EU_upgrade+1])
+end
+
+minetest.register_node("technic:tool_workshop", {
+	description = S("%s Tool Workshop"):format("MV"),
+	paramtype2 = "facedir",
+	tiles = {
+		"technic_workshop_top.png"..tube_entry,
+		"technic_machine_bottom.png"..tube_entry,
+		"technic_workshop_side.png"..tube_entry,
+		"technic_workshop_side.png"..tube_entry,
+		"technic_workshop_side.png"..tube_entry,
+		"technic_workshop_side.png"
+	},
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+		technic_machine=1, technic_mv=1, tubedevice=1, tubedevice_receiver=1},
+	connect_sides = {"bottom", "back", "left", "right"},
+	sounds = default.node_sound_wood_defaults(),
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("%s Tool Workshop"):format("MV"))
+		meta:set_string("formspec", workshop_formspec)
+		local inv = meta:get_inventory()
+		inv:set_size("src", 1)
+		inv:set_size("upgrade1", 1)
+		inv:set_size("upgrade2", 1)
+	end,
+	can_dig = technic.machine_can_dig,
+	allow_metadata_inventory_put = technic.machine_inventory_put,
+	allow_metadata_inventory_take = technic.machine_inventory_take,
+	tube = {
+		can_insert = function (pos, node, stack, direction)
+			return minetest.get_meta(pos):get_inventory():room_for_item("src", stack)
+		end,
+		insert_object = function (pos, node, stack, direction)
+			return minetest.get_meta(pos):get_inventory():add_item("src", stack)
+		end,
+		connect_sides = {left = 1, right = 1, back = 1, top = 1, bottom = 1},
+	},
+	technic_run = run,
+	after_place_node = pipeworks.after_place,
+	after_dig_node = technic.machine_after_dig_node
+})
+
+technic.register_machine("MV", "technic:tool_workshop", technic.receiver)
+

mods/technic_plus/technic/machines/MV/wind_mill.lua

@@ -0,0 +1,96 @@
+
+local S = technic.getter
+
+minetest.register_craft({
+	output = 'technic:wind_mill_frame 5',
+	recipe = {
+		{'technic:carbon_steel_ingot', '',                           'technic:carbon_steel_ingot'},
+		{'',                           'technic:carbon_steel_ingot', ''},
+		{'technic:carbon_steel_ingot', '',                           'technic:carbon_steel_ingot'},
+	}
+})
+
+minetest.register_craft({
+	output = 'technic:wind_mill',
+	recipe = {
+		{'',                           'basic_materials:motor',              ''},
+		{'technic:carbon_steel_ingot', 'technic:carbon_steel_block', 'technic:carbon_steel_ingot'},
+		{'',                           'technic:mv_cable',           ''},
+	}
+})
+
+minetest.register_node("technic:wind_mill_frame", {
+	description = S("Wind Mill Frame"),
+	drawtype = "glasslike_framed",
+	tiles = {"technic_carbon_steel_block.png", "default_glass.png"},
+	sunlight_propagates = true,
+	groups = {cracky=3},
+	sounds = default.node_sound_stone_defaults(),
+	paramtype = "light",
+})
+
+local function check_wind_mill(pos)
+	if pos.y < 30 then
+		return false
+	end
+	pos = {x=pos.x, y=pos.y, z=pos.z}
+	for i = 1, 20 do
+		pos.y = pos.y - 1
+		local node = minetest.get_node_or_nil(pos)
+		if not node then
+			-- we reached CONTENT_IGNORE, we can assume, that nothing changed
+			-- as the user will have to load the block to change it
+			return
+		end
+		if node.name ~= "technic:wind_mill_frame" then
+			return false
+		end
+	end
+	return true
+end
+
+local run = function(pos, node)
+	local meta = minetest.get_meta(pos)
+	local machine_name = S("Wind %s Generator"):format("MV")
+
+	local check = check_wind_mill(pos)
+	if check == false then
+		meta:set_int("MV_EU_supply", 0)
+		meta:set_string("infotext", S("%s Improperly Placed"):format(machine_name))
+	elseif check == true then
+		local power = math.min(pos.y * 100, 5000)
+		meta:set_int("MV_EU_supply", power)
+		meta:set_string("infotext", S("@1 (@2)", machine_name,
+			technic.EU_string(power)))
+	end
+	-- check == nil: assume nothing has changed
+end
+
+minetest.register_node("technic:wind_mill", {
+	description = S("Wind %s Generator"):format("MV"),
+	tiles = {"technic_carbon_steel_block.png"},
+	paramtype2 = "facedir",
+	groups = {cracky=1, technic_machine=1, technic_mv=1},
+	connect_sides = {"top", "bottom", "back", "left", "right"},
+	sounds = default.node_sound_stone_defaults(),
+	drawtype = "nodebox",
+	paramtype = "light",
+	node_box = {
+		type = "fixed",
+		fixed = {
+			{-0.5, -0.5, -0.5, 0.5, 0.5, 0.5}, -- Main box
+			{-0.1, -0.1, -0.5,  0.1, 0.1, -0.6}, -- Shaft
+			{-0.1, -1,   -0.6,  0.1, 1,   -0.7}, -- Vertical blades
+			{-1,   -0.1, -0.6,  1,   0.1, -0.7}, -- Horizontal blades
+		}
+	},
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("Wind %s Generator"):format("MV"))
+		meta:set_int("MV_EU_supply", 0)
+	end,
+	technic_run = run,
+})
+
+technic.register_machine("MV", "technic:wind_mill", technic.producer)
+

mods/technic_plus/technic/machines/compat/digtron.lua

@@ -0,0 +1,30 @@
+--
+-- Compatibility hacks for digtron to work well with technic plus new network system
+--
+-- More information:
+-- https://github.com/mt-mods/technic/issues/100
+--
+
+local function power_connector_compat()
+	local digtron_technic_run = minetest.registered_nodes["digtron:power_connector"].technic_run
+	minetest.override_item("digtron:power_connector",{
+		technic_run = function(pos, node)
+			local network_id = technic.pos2network(pos)
+			local sw_pos = network_id and technic.network2sw_pos(network_id)
+			local meta = minetest.get_meta(pos)
+			meta:set_string("HV_network", sw_pos and minetest.pos_to_string(sw_pos) or "")
+			return digtron_technic_run(pos, node)
+		end,
+		technic_on_disable = function(pos, node)
+			local meta = minetest.get_meta(pos)
+			meta:set_string("HV_network", "")
+			meta:set_string("HV_EU_input", "")
+		end,
+	})
+end
+
+minetest.register_on_mods_loaded(function()
+	if minetest.registered_nodes["digtron:power_connector"] then
+		power_connector_compat()
+	end
+end)

mods/technic_plus/technic/machines/init.lua

@@ -0,0 +1,180 @@
+local path = technic.modpath.."/machines"
+
+technic.digilines = {
+	rules = {
+		-- digilines.rules.default
+		{x= 1,y= 0,z= 0},{x=-1,y= 0,z= 0}, -- along x beside
+		{x= 0,y= 0,z= 1},{x= 0,y= 0,z=-1}, -- along z beside
+		{x= 1,y= 1,z= 0},{x=-1,y= 1,z= 0}, -- 1 node above along x diagonal
+		{x= 0,y= 1,z= 1},{x= 0,y= 1,z=-1}, -- 1 node above along z diagonal
+		{x= 1,y=-1,z= 0},{x=-1,y=-1,z= 0}, -- 1 node below along x diagonal
+		{x= 0,y=-1,z= 1},{x= 0,y=-1,z=-1}, -- 1 node below along z diagonal
+		-- added rules for digi cable
+		{x =  0, y = -1, z = 0}, -- along y below
+	}
+}
+
+-- https://github.com/mt-mods/technic/issues/100
+dofile(path.."/compat/digtron.lua")
+
+dofile(path.."/network.lua")
+
+dofile(path.."/register/init.lua")
+
+-- Tiers
+dofile(path.."/LV/init.lua")
+dofile(path.."/MV/init.lua")
+dofile(path.."/HV/init.lua")
+
+dofile(path.."/switching_station.lua")
+dofile(path.."/switching_station_globalstep.lua")
+
+dofile(path.."/power_monitor.lua")
+dofile(path.."/supply_converter.lua")
+
+dofile(path.."/other/init.lua")
+
+--
+-- Technic power network administrative functions
+--
+
+local active_networks = technic.active_networks
+local networks = technic.networks
+local cables = technic.cables
+--
+-- Enable / disable technic globalstep
+--
+technic.powerctrl_state = true
+minetest.register_chatcommand("powerctrl", {
+	params = "[on|off]",
+	description = "Enables or disables technic network globalstep handler",
+	privs = { [technic.config:get("admin_priv")] = true },
+	func = function(name, state)
+		if state == "on" then
+			technic.powerctrl_state = true
+		elseif state == "off" then
+			technic.powerctrl_state = false
+		end
+		minetest.chat_send_player(name, ("Technic network globalstep %s."):format(
+			technic.powerctrl_state and "enabled" or "disabled"
+		))
+	end
+})
+
+--
+-- List all active networks with additional data
+--
+minetest.register_chatcommand("technic_get_active_networks", {
+	params = "[minlag]",
+	description = "list all active networks with additional network data",
+	privs = { [technic.config:get("admin_priv")] = true },
+	func = function(name, minlag)
+		minlag = tonumber(minlag) or 0
+		local activecount = 0
+		local network_info = {}
+		local netcount = 0
+		local nodecount = 0
+		local function align(s, w)
+			s = tostring(s)
+			return string.rep(' ', w - #s) .. s
+		end
+		local function net2str(id)
+			local p=technic.network2pos(id)
+			return align(("%s,%s,%s"):format(p.x,p.y,p.z),21)
+		end
+		for id,net in pairs(active_networks) do
+			if minlag == 0 or (net.lag and net.lag >= minlag * 1000) then
+				activecount = activecount + 1
+				table.insert(network_info, ("Pos:%s PR:%s RE:%s BA:%s Skip:%s Lag:%sms"):format(
+					net2str(id), align(#net.PR_nodes, 4), align(#net.RE_nodes, 4), align(#net.BA_nodes, 4),
+					align(net.skip, 3), net.lag and align(("%0.2f"):format(net.lag / 1000), 6) or ""
+				))
+			end
+		end
+		for _ in pairs(networks) do netcount = netcount + 1 end
+		for _ in pairs(cables) do nodecount = nodecount + 1 end
+		minetest.chat_send_player(name,
+			("Cached networks: %d active, %d total, %d nodes, %0.2f max lag.\n%s"):format(
+			activecount, netcount, nodecount, technic.get_max_lag(), table.concat(network_info, "\n")
+		))
+	end
+})
+
+--
+-- Clear technic active networks
+--
+minetest.register_chatcommand("technic_flush_switch_cache", {
+	description = "removes all active networks from the cache",
+	privs = { [technic.config:get("admin_priv")] = true },
+	func = function(name)
+		local activecount = 0
+		for id in pairs(active_networks) do
+			activecount = activecount + 1
+			active_networks[id] = nil
+		end
+		minetest.chat_send_player(name, ("Network data removed: %d active networks deactivated."):format(activecount))
+	end
+})
+
+--
+-- Completely clear all technic network caches
+--
+minetest.register_chatcommand("technic_clear_network_data", {
+	description = "removes all networks and network nodes from the cache",
+	privs = { [technic.config:get("admin_priv")] = true },
+	func = function(name)
+		-- Clear all network data keeping all reference links intact
+		local activecount = 0
+		local netcount = 0
+		local nodecount = 0
+		for id in pairs(active_networks) do
+			activecount = activecount + 1
+			active_networks[id] = nil
+		end
+		for id in pairs(networks) do
+			netcount = netcount + 1
+			networks[id] = nil
+		end
+		for id in pairs(cables) do
+			nodecount = nodecount + 1
+			cables[id] = nil
+		end
+		minetest.chat_send_player(name, string.format(
+			"Network data removed: %d active networks, %d total networks, %d network nodes.",
+			activecount, netcount, nodecount
+		))
+	end
+})
+
+--
+-- Metadata cleanup LBM, removes old metadata values from nodes
+--
+--luacheck: ignore 511
+if false then
+	minetest.register_lbm({
+		name = "technic:metadata-cleanup",
+		nodenames = {
+			"group:technic_machine",
+			"group:technic_all_tiers",
+			"technic:switching_station",
+			"technic:power_monitor",
+		},
+		action = function(pos, node)
+			-- Delete all listed metadata key/value pairs from technic machines
+			local keys = {
+				"LV_EU_timeout", "MV_EU_timeout", "HV_EU_timeout",
+				"LV_network", "MV_network", "HV_network",
+				"active_pos", "supply", "demand",
+				"battery_count", "battery_charge", "battery_charge_max",
+			}
+			local meta = minetest.get_meta(pos)
+			for _,key in ipairs(keys) do
+				-- Value of `""` will delete the key.
+				meta:set_string(key, "")
+			end
+			if node.name == "technic:switching_station" then
+				meta:set_string("active", "")
+			end
+		end,
+	})
+end

mods/technic_plus/technic/machines/network.lua

@@ -0,0 +1,586 @@
+--
+-- Power network specific functions and data should live here
+--
+local S = technic.getter
+
+local switch_max_range = tonumber(technic.config:get("switch_max_range"))
+local off_delay_seconds = tonumber(technic.config:get("switch_off_delay_seconds"))
+
+technic.active_networks = {}
+local networks = {}
+technic.networks = networks
+local cables = {}
+technic.cables = cables
+
+local poshash = minetest.hash_node_position
+local hashpos = minetest.get_position_from_hash
+
+function technic.create_network(sw_pos)
+	local network_id = poshash({x=sw_pos.x,y=sw_pos.y-1,z=sw_pos.z})
+	technic.build_network(network_id)
+	return network_id
+end
+
+function technic.activate_network(network_id, timeout)
+	-- timeout is optional ttl for network in seconds, if not specified use default
+	local network = networks[network_id]
+	if network then
+		-- timeout is absolute time in microseconds
+		network.timeout = minetest.get_us_time() + ((timeout or off_delay_seconds) * 1000 * 1000)
+		technic.active_networks[network_id] = network
+	end
+end
+
+function technic.sw_pos2tier(pos, use_vm)
+	-- Get cable tier for switching station or nil if no cable
+	-- use_vm true to use VoxelManip to load node
+	local cable_pos = {x=pos.x,y=pos.y-1,z=pos.z}
+	if use_vm then
+		technic.get_or_load_node(cable_pos)
+	end
+	return technic.get_cable_tier(minetest.get_node(cable_pos).name)
+end
+
+-- Destroy network data
+function technic.remove_network(network_id)
+	for pos_hash,cable_net_id in pairs(cables) do
+		if cable_net_id == network_id then
+			cables[pos_hash] = nil
+		end
+	end
+	networks[network_id] = nil
+	technic.active_networks[network_id] = nil
+end
+
+-- Remove machine or cable from network
+local network_node_arrays = {"PR_nodes","BA_nodes","RE_nodes"}
+function technic.remove_network_node(network_id, pos)
+	local network = networks[network_id]
+	if not network then return end
+	-- Clear hash tables, cannot use table.remove
+	local node_id = poshash(pos)
+	cables[node_id] = nil
+	network.all_nodes[node_id] = nil
+	-- TODO: All following things can be skipped if node is not machine
+	--   check here if it is or is not cable
+	--   or add separate function to remove cables and move responsibility to caller
+	-- Clear indexed arrays, do NOT leave holes
+	local machine_removed = false
+	for _,tblname in ipairs(network_node_arrays) do
+		local tbl = network[tblname]
+		for i=#tbl,1,-1 do
+			local mpos = tbl[i]
+			if mpos.x == pos.x and mpos.y == pos.y and mpos.z == pos.z then
+				table.remove(tbl, i)
+				machine_removed = true
+				break
+			end
+		end
+	end
+	if machine_removed then
+		-- Machine can still be in world, just not connected to any network. If so then disable it.
+		local node = minetest.get_node(pos)
+		technic.disable_machine(pos, node)
+	end
+end
+
+function technic.sw_pos2network(pos)
+	return cables[poshash({x=pos.x,y=pos.y-1,z=pos.z})]
+end
+
+function technic.sw_pos2network(pos)
+	return cables[poshash({x=pos.x,y=pos.y-1,z=pos.z})]
+end
+
+function technic.pos2network(pos)
+	return cables[poshash(pos)]
+end
+
+function technic.network2pos(network_id)
+	return hashpos(network_id)
+end
+
+function technic.network2sw_pos(network_id)
+	-- Return switching station position for network.
+	-- It is not guaranteed that position actually contains switching station.
+	local sw_pos = hashpos(network_id)
+	sw_pos.y = sw_pos.y + 1
+	return sw_pos
+end
+
+function technic.network_infotext(network_id, text)
+	if networks[network_id] == nil then return end
+	if text then
+		networks[network_id].infotext = text
+	else
+		return networks[network_id].infotext
+	end
+end
+
+local node_timeout = {}
+local default_timeout = 2
+
+function technic.set_default_timeout(timeout)
+	default_timeout = timeout or 2
+end
+
+function technic.get_timeout(tier, pos)
+	if node_timeout[tier] == nil then
+		-- it is normal that some multi tier nodes always drop here when checking all LV, MV and HV tiers
+		return 0
+	end
+	return node_timeout[tier][poshash(pos)] or 0
+end
+
+local function touch_node(tier, pos, timeout)
+	if node_timeout[tier] == nil then
+		-- this should get built up during registration
+		node_timeout[tier] = {}
+	end
+	node_timeout[tier][poshash(pos)] = timeout or default_timeout
+end
+technic.touch_node = touch_node
+
+function technic.disable_machine(pos, node)
+	local nodedef = minetest.registered_nodes[node.name]
+	if nodedef and nodedef.technic_disabled_machine_name then
+		node.name = nodedef.technic_disabled_machine_name
+		minetest.swap_node(pos, node)
+	elseif nodedef and nodedef.technic_on_disable then
+		nodedef.technic_on_disable(pos, node)
+	end
+	if nodedef then
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("%s Has No Network"):format(nodedef.description))
+	end
+	local node_id = poshash(pos)
+	for _,nodes in pairs(node_timeout) do
+		nodes[node_id] = nil
+	end
+end
+
+--
+-- Network overloading (incomplete cheat mitigation)
+--
+local overload_reset_time = tonumber(technic.config:get("network_overload_reset_time"))
+local overloaded_networks = {}
+
+local function overload_network(network_id)
+	local network = networks[network_id]
+	if network then
+		network.supply = 0
+		network.battery_charge = 0
+	end
+	overloaded_networks[network_id] = minetest.get_us_time() + (overload_reset_time * 1000 * 1000)
+end
+technic.overload_network = overload_network
+
+local function reset_overloaded(network_id)
+	local remaining = math.max(0, overloaded_networks[network_id] - minetest.get_us_time())
+	if remaining == 0 then
+		-- Clear cache, remove overload and restart network
+		technic.remove_network(network_id)
+		overloaded_networks[network_id] = nil
+	end
+	-- Returns 0 when network reset or remaining time if reset timer has not expired yet
+	return remaining
+end
+technic.reset_overloaded = reset_overloaded
+
+local function is_overloaded(network_id)
+	return overloaded_networks[network_id]
+end
+technic.is_overloaded = is_overloaded
+
+--
+-- Functions to traverse the electrical network
+--
+
+-- Add a machine node to the LV/MV/HV network
+local function add_network_machine(nodes, pos, network_id, all_nodes, multitier)
+	local node_id = poshash(pos)
+	local net_id_old = cables[node_id]
+	if net_id_old == nil or (multitier and net_id_old ~= network_id and all_nodes[node_id] == nil) then
+		-- Add machine to network only if it is not already added
+		table.insert(nodes, pos)
+		-- FIXME: Machines connecting to multiple networks should have way to store multiple network ids
+		cables[node_id] = network_id
+		all_nodes[node_id] = pos
+		return true
+	elseif not multitier and net_id_old ~= network_id then
+		-- Do not allow running from multiple networks, trigger overload
+		overload_network(network_id)
+		overload_network(net_id_old)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext",S("Network Overloaded"))
+	end
+end
+
+-- Add a wire node to the LV/MV/HV network
+local function add_cable_node(nodes, pos, network_id, queue)
+	local node_id = poshash(pos)
+	if not cables[node_id] then
+		cables[node_id] = network_id
+		nodes[node_id] = pos
+		table.insert(queue, pos)
+	end
+end
+
+-- Generic function to add found connected nodes to the right classification array
+local function add_network_node(PR_nodes, RE_nodes, BA_nodes, all_nodes, pos, machines, tier, network_id, queue)
+	technic.get_or_load_node(pos)
+	local name = minetest.get_node(pos).name
+
+	if technic.is_tier_cable(name, tier) then
+		add_cable_node(all_nodes, pos, network_id, queue)
+	elseif machines[name] then
+		if     machines[name] == technic.producer then
+			add_network_machine(PR_nodes, pos, network_id, all_nodes)
+		elseif machines[name] == technic.receiver then
+			add_network_machine(RE_nodes, pos, network_id, all_nodes)
+		elseif machines[name] == technic.producer_receiver then
+			if add_network_machine(PR_nodes, pos, network_id, all_nodes, true) then
+				table.insert(RE_nodes, pos)
+			end
+		elseif machines[name] == technic.battery then
+			add_network_machine(BA_nodes, pos, network_id, all_nodes)
+		end
+	end
+end
+
+-- Generic function to add single nodes to the right classification array of existing network
+function technic.add_network_node(pos, network)
+	add_network_node(
+		network.PR_nodes,
+		network.RE_nodes,
+		network.BA_nodes,
+		network.all_nodes,
+		pos,
+		technic.machines[network.tier],
+		network.tier,
+		network.id,
+		{}
+	)
+end
+
+-- Traverse a network given a list of machines and a cable type name
+local function traverse_network(PR_nodes, RE_nodes, BA_nodes, all_nodes, pos, machines, tier, network_id, queue)
+	local positions = {
+		{x=pos.x+1, y=pos.y,   z=pos.z},
+		{x=pos.x-1, y=pos.y,   z=pos.z},
+		{x=pos.x,   y=pos.y+1, z=pos.z},
+		{x=pos.x,   y=pos.y-1, z=pos.z},
+		{x=pos.x,   y=pos.y,   z=pos.z+1},
+		{x=pos.x,   y=pos.y,   z=pos.z-1}}
+	for i, cur_pos in pairs(positions) do
+		if not all_nodes[poshash(cur_pos)] then
+			add_network_node(PR_nodes, RE_nodes, BA_nodes, all_nodes, cur_pos, machines, tier, network_id, queue)
+		end
+	end
+end
+
+local function touch_nodes(list, tier)
+	for _, pos in ipairs(list) do
+		touch_node(tier, pos) -- Touch node
+	end
+end
+
+local function get_network(network_id, tier)
+	local cached = networks[network_id]
+	if cached and cached.tier == tier then
+		touch_nodes(cached.PR_nodes, tier)
+		touch_nodes(cached.BA_nodes, tier)
+		touch_nodes(cached.RE_nodes, tier)
+		return cached.PR_nodes, cached.BA_nodes, cached.RE_nodes
+	end
+	return technic.build_network(network_id)
+end
+
+function technic.add_network_branch(queue, network)
+	-- Adds whole branch to network, queue positions can be used to bypass sub branches
+	local PR_nodes = network.PR_nodes -- Indexed array
+	local BA_nodes = network.BA_nodes -- Indexed array
+	local RE_nodes = network.RE_nodes -- Indexed array
+	local all_nodes = network.all_nodes -- Hash table
+	local network_id = network.id
+	local tier = network.tier
+	local machines = technic.machines[tier]
+	local sw_pos = technic.network2sw_pos(network_id)
+	--print(string.format("technic.add_network_branch(%s, %s, %.17g)",queue,minetest.pos_to_string(sw_pos),network.id))
+	while next(queue) do
+		local to_visit = {}
+		for _, pos in ipairs(queue) do
+			if vector.distance(pos, sw_pos) > switch_max_range then
+				-- max range exceeded
+				return
+			end
+			traverse_network(PR_nodes, RE_nodes, BA_nodes, all_nodes, pos,
+					machines, tier, network_id, to_visit)
+		end
+		queue = to_visit
+	end
+end
+
+-- Battery charge status updates for network
+local function update_battery(self, charge, max_charge, supply, demand)
+	self.battery_charge = self.battery_charge + charge
+	self.battery_charge_max = self.battery_charge_max + max_charge
+	self.battery_supply = self.battery_supply + supply
+	self.battery_demand = self.battery_demand + demand
+	if demand ~= 0 then
+		self.BA_count_active = self.BA_count_active + 1
+		self.BA_charge_active = self.BA_charge_active + charge
+	end
+end
+
+-- Moving average function generator
+local function sma(period)
+	local values = {}
+	local index = 1
+	local sum = 0
+	return function(n)
+		-- Add new value and return average
+		sum = sum - (values[index] or 0) + n
+		values[index] = n
+		index = index ~= period and index + 1 or 1
+		return sum / #values
+	end
+end
+
+function technic.build_network(network_id)
+	technic.remove_network(network_id)
+	local sw_pos = technic.network2sw_pos(network_id)
+	local tier = technic.sw_pos2tier(sw_pos)
+	if not tier then
+		return
+	end
+	local network = {
+		-- Basic network data and lookup table for attached nodes (no switching stations)
+		id = network_id, tier = tier, all_nodes = {},
+		-- Indexed arrays for iteration by machine type
+		PR_nodes = {}, RE_nodes = {}, BA_nodes = {},
+		-- Power generation, usage and capacity related variables
+		supply = 0, demand = 0, battery_charge = 0, battery_charge_max = 0,
+		BA_count_active = 0, BA_charge_active = 0, battery_supply = 0, battery_demand = 0,
+		-- Battery status update function
+		update_battery = update_battery,
+		-- Network activation and excution control
+		timeout = 0, skip = 0, lag = 0, average_lag = sma(5)
+	}
+	-- Add first cable (one that is holding network id) and build network
+	local queue = {}
+	add_cable_node(network.all_nodes, technic.network2pos(network_id), network_id, queue)
+	technic.add_network_branch(queue, network)
+	network.battery_count = #network.BA_nodes
+	-- Add newly built network to cache array
+	networks[network_id] = network
+	-- And return producers, batteries and receivers (should this simply return network?)
+	return network.PR_nodes, network.BA_nodes, network.RE_nodes
+end
+
+--
+-- Execute technic power network
+--
+local node_technic_run = {}
+minetest.register_on_mods_loaded(function()
+	for name, _ in pairs(technic.machine_tiers) do
+		if type(minetest.registered_nodes[name].technic_run) == "function" then
+			node_technic_run[name] = minetest.registered_nodes[name].technic_run
+		end
+	end
+end)
+
+local function run_nodes(list, vm, run_stage, network)
+	for _, pos in ipairs(list) do
+		local node = minetest.get_node_or_nil(pos)
+		if not node then
+			vm:read_from_map(pos, pos)
+			node = minetest.get_node_or_nil(pos)
+		end
+		if node and node.name and node_technic_run[node.name] then
+			node_technic_run[node.name](pos, node, run_stage, network)
+		end
+	end
+end
+
+local mesecons_path = minetest.get_modpath("mesecons")
+local digilines_path = minetest.get_modpath("digilines")
+
+function technic.network_run(network_id)
+	--
+	-- !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!!
+	-- TODO: This function requires a lot of cleanup
+	-- It is moved here from switching_station.lua and still
+	-- contain a lot of switching station specific stuff which
+	-- should be removed and/or refactored.
+	--
+
+	local pos = technic.network2sw_pos(network_id)
+	local t0 = minetest.get_us_time()
+
+	local PR_nodes
+	local BA_nodes
+	local RE_nodes
+
+	local tier = technic.sw_pos2tier(pos)
+	local network
+	if tier then
+		PR_nodes, BA_nodes, RE_nodes = get_network(network_id, tier)
+		if technic.is_overloaded(network_id) then return end
+		network = networks[network_id]
+	else
+		--dprint("Not connected to a network")
+		technic.network_infotext(network_id, S("%s Has No Network"):format(S("Switching Station")))
+		return
+	end
+
+	-- Reset battery data for updates
+	network.battery_charge = 0
+	network.battery_charge_max = 0
+	network.battery_supply = 0
+	network.battery_demand = 0
+	network.BA_count_active = 0
+	network.BA_charge_active = 0
+
+	local vm = VoxelManip()
+	run_nodes(PR_nodes, vm, technic.producer)
+	run_nodes(RE_nodes, vm, technic.receiver)
+	run_nodes(BA_nodes, vm, technic.battery, network)
+
+	-- Strings for the meta data
+	local eu_demand_str    = tier.."_EU_demand"
+	local eu_input_str     = tier.."_EU_input"
+	local eu_supply_str    = tier.."_EU_supply"
+
+	-- Distribute charge equally across multiple batteries.
+	local charge_distributed = math.floor(network.BA_charge_active / network.BA_count_active)
+	for n, pos1 in pairs(BA_nodes) do
+		local meta1 = minetest.get_meta(pos1)
+		if (meta1:get_int(eu_demand_str) ~= 0) then
+			meta1:set_int("internal_EU_charge", charge_distributed)
+		end
+	end
+
+	-- Get all the power from the PR nodes
+	local PR_eu_supply = 0 -- Total power
+	for _, pos1 in pairs(PR_nodes) do
+		local meta1 = minetest.get_meta(pos1)
+		PR_eu_supply = PR_eu_supply + meta1:get_int(eu_supply_str)
+	end
+	--dprint("Total PR supply:"..PR_eu_supply)
+
+	-- Get all the demand from the RE nodes
+	local RE_eu_demand = 0
+	for _, pos1 in pairs(RE_nodes) do
+		local meta1 = minetest.get_meta(pos1)
+		RE_eu_demand = RE_eu_demand + meta1:get_int(eu_demand_str)
+	end
+	--dprint("Total RE demand:"..RE_eu_demand)
+
+	technic.network_infotext(network_id, S("@1. Supply: @2 Demand: @3",
+			S("Switching Station"), technic.EU_string(PR_eu_supply),
+			technic.EU_string(RE_eu_demand)))
+
+	-- If mesecon signal and power supply or demand changed then
+	-- send them via digilines.
+	if mesecons_path and digilines_path and mesecon.is_powered(pos) then
+		if PR_eu_supply ~= network.supply or
+				RE_eu_demand ~= network.demand then
+			local meta = minetest.get_meta(pos)
+			local channel = meta:get_string("channel")
+			digilines.receptor_send(pos, technic.digilines.rules, channel, {
+				supply = PR_eu_supply,
+				demand = RE_eu_demand
+			})
+		end
+	end
+
+	-- Data that will be used by the power monitor
+	network.supply = PR_eu_supply
+	network.demand = RE_eu_demand
+	network.battery_count = #BA_nodes
+
+	-- If the PR supply is enough for the RE demand supply them all
+	local BA_eu_demand = network.battery_demand
+	if PR_eu_supply >= RE_eu_demand then
+	--dprint("PR_eu_supply"..PR_eu_supply.." >= RE_eu_demand"..RE_eu_demand)
+		for _, pos1 in pairs(RE_nodes) do
+			local meta1 = minetest.get_meta(pos1)
+			local eu_demand = meta1:get_int(eu_demand_str)
+			meta1:set_int(eu_input_str, eu_demand)
+		end
+		-- We have a surplus, so distribute the rest equally to the BA nodes
+		-- Let's calculate the factor of the demand
+		PR_eu_supply = PR_eu_supply - RE_eu_demand
+		local charge_factor = 0 -- Assume all batteries fully charged
+		if BA_eu_demand > 0 then
+			charge_factor = PR_eu_supply / BA_eu_demand
+		end
+		-- TODO: EU input for all batteries: math.floor(BA_eu_demand * charge_factor * #BA_nodes)
+		for n, pos1 in pairs(BA_nodes) do
+			local meta1 = minetest.get_meta(pos1)
+			local eu_demand = meta1:get_int(eu_demand_str)
+			meta1:set_int(eu_input_str, math.floor(eu_demand * charge_factor))
+			--dprint("Charging battery:"..math.floor(eu_demand*charge_factor))
+		end
+		local t1 = minetest.get_us_time()
+		local diff = t1 - t0
+		if diff > 50000 then
+			minetest.log("warning", "[technic] [+supply] technic_run took " .. diff .. " us at " .. minetest.pos_to_string(pos))
+		end
+
+		return
+	end
+
+	-- If the PR supply is not enough for the RE demand we will discharge the batteries too
+	local BA_eu_supply = network.battery_supply
+	if PR_eu_supply + BA_eu_supply >= RE_eu_demand then
+		--dprint("PR_eu_supply "..PR_eu_supply.."+BA_eu_supply "..BA_eu_supply.." >= RE_eu_demand"..RE_eu_demand)
+		for _, pos1 in pairs(RE_nodes) do
+			local meta1  = minetest.get_meta(pos1)
+			local eu_demand = meta1:get_int(eu_demand_str)
+			meta1:set_int(eu_input_str, eu_demand)
+		end
+		-- We have a deficit, so distribute to the BA nodes
+		-- Let's calculate the factor of the supply
+		local charge_factor = 0 -- Assume all batteries depleted
+		if BA_eu_supply > 0 then
+			charge_factor = (PR_eu_supply - RE_eu_demand) / BA_eu_supply
+		end
+		for n,pos1 in pairs(BA_nodes) do
+			local meta1 = minetest.get_meta(pos1)
+			local eu_supply = meta1:get_int(eu_supply_str)
+			meta1:set_int(eu_input_str, math.floor(eu_supply * charge_factor))
+			--dprint("Discharging battery:"..math.floor(eu_supply*charge_factor))
+		end
+		local t1 = minetest.get_us_time()
+		local diff = t1 - t0
+		if diff > 50000 then
+			minetest.log("warning", "[technic] [-supply] technic_run took " .. diff .. " us at " .. minetest.pos_to_string(pos))
+		end
+
+		return
+	end
+
+	-- If the PR+BA supply is not enough for the RE demand: Power only the batteries
+	local charge_factor = 0 -- Assume all batteries fully charged
+	if BA_eu_demand > 0 then
+		charge_factor = PR_eu_supply / BA_eu_demand
+	end
+	for n, pos1 in pairs(BA_nodes) do
+		local meta1 = minetest.get_meta(pos1)
+		local eu_demand = meta1:get_int(eu_demand_str)
+		meta1:set_int(eu_input_str, math.floor(eu_demand * charge_factor))
+	end
+	for n, pos1 in pairs(RE_nodes) do
+		local meta1 = minetest.get_meta(pos1)
+		meta1:set_int(eu_input_str, 0)
+	end
+
+	local t1 = minetest.get_us_time()
+	local diff = t1 - t0
+	if diff > 50000 then
+		minetest.log("warning", "[technic] technic_run took " .. diff .. " us at " .. minetest.pos_to_string(pos))
+	end
+
+end

mods/technic_plus/technic/machines/other/anchor.lua

@@ -0,0 +1,129 @@
+local S = technic.getter
+
+local desc = S("Administrative World Anchor")
+
+local function compute_forceload_positions(pos, meta)
+	local radius = meta:get_int("radius")
+	local minpos = vector.subtract(pos, vector.new(radius, radius, radius))
+	local maxpos = vector.add(pos, vector.new(radius, radius, radius))
+	local minbpos = {}
+	local maxbpos = {}
+	for _, coord in ipairs({"x","y","z"}) do
+		minbpos[coord] = math.floor(minpos[coord] / 16) * 16
+		maxbpos[coord] = math.floor(maxpos[coord] / 16) * 16
+	end
+	local flposes = {}
+	for x = minbpos.x, maxbpos.x, 16 do
+		for y = minbpos.y, maxbpos.y, 16 do
+			for z = minbpos.z, maxbpos.z, 16 do
+				table.insert(flposes, vector.new(x, y, z))
+			end
+		end
+	end
+	return flposes
+end
+
+local function currently_forceloaded_positions(meta)
+	local ser = meta:get_string("forceloaded")
+	return ser == "" and {} or minetest.deserialize(ser)
+end
+
+local function forceload_off(meta)
+	local flposes = currently_forceloaded_positions(meta)
+	meta:set_string("forceloaded", "")
+	for _, p in ipairs(flposes) do
+		minetest.forceload_free_block(p)
+	end
+end
+
+local function forceload_on(pos, meta)
+	local want_flposes = compute_forceload_positions(pos, meta)
+	local have_flposes = {}
+	for _, p in ipairs(want_flposes) do
+		if minetest.forceload_block(p) then
+			table.insert(have_flposes, p)
+		end
+	end
+	meta:set_string("forceloaded", #have_flposes == 0 and "" or minetest.serialize(have_flposes))
+end
+
+local function set_display(pos, meta)
+	meta:set_string("infotext", S(meta:get_int("enabled") ~= 0 and "%s Enabled" or "%s Disabled"):format(desc))
+	meta:set_string("formspec",
+		"size[5,3.5]"..
+		"item_image[0,0;1,1;technic:admin_anchor]"..
+		"label[1,0;"..minetest.formspec_escape(desc).."]"..
+		"label[0,1;"..minetest.formspec_escape(S("Owner:").." "..meta:get_string("owner")).."]"..
+		(meta:get_int("locked") == 0 and
+			"button[3,1;2,1;lock;"..minetest.formspec_escape(S("Unlocked")).."]" or
+			"button[3,1;2,1;unlock;"..minetest.formspec_escape(S("Locked")).."]")..
+		"field[0.25,2.3;1,1;radius;"..minetest.formspec_escape(S("Radius:"))..";"..meta:get_int("radius").."]"..
+		(meta:get_int("enabled") == 0 and
+			"button[3,2;2,1;enable;"..minetest.formspec_escape(S("Disabled")).."]" or
+			"button[3,2;2,1;disable;"..minetest.formspec_escape(S("Enabled")).."]")..
+		"label[0,3;"..minetest.formspec_escape(S("Keeping %d/%d map blocks loaded"):format(
+				#currently_forceloaded_positions(meta), #compute_forceload_positions(pos, meta))).."]")
+end
+
+minetest.register_node("technic:admin_anchor", {
+	description = desc,
+	drawtype = "normal",
+	tiles = {"technic_admin_anchor.png"},
+	is_ground_content = true,
+	groups = {cracky=3, not_in_creative_inventory=1},
+	sounds = default.node_sound_stone_defaults(),
+	after_place_node = function (pos, placer)
+		local meta = minetest.get_meta(pos)
+		if placer and placer:is_player() then
+			meta:set_string("owner", placer:get_player_name())
+		end
+		set_display(pos, meta)
+	end,
+	can_dig = function (pos, player)
+		local meta = minetest.get_meta(pos)
+		return meta:get_int("locked") == 0 or (player and player:is_player()
+				and player:get_player_name() == meta:get_string("owner"))
+	end,
+	on_destruct = function (pos)
+		local meta = minetest.get_meta(pos)
+		forceload_off(meta)
+	end,
+	on_receive_fields = function (pos, formname, fields, sender)
+		local meta = minetest.get_meta(pos)
+		if (meta:get_int("locked") ~= 0 or fields.lock) and
+				not (sender and sender:is_player() and
+					sender:get_player_name() == meta:get_string("owner")) then
+			return
+		end
+		if fields.unlock then meta:set_int("locked", 0) end
+		if fields.lock then meta:set_int("locked", 1) end
+		if fields.disable or fields.enable or fields.radius then
+			forceload_off(meta)
+			if fields.disable then meta:set_int("enabled", 0) end
+			if fields.enable then meta:set_int("enabled", 1) end
+			if fields.radius and string.find(fields.radius, "^[0-9]+$") and tonumber(fields.radius) < 256 then
+				meta:set_int("radius", fields.radius)
+			end
+			if meta:get_int("enabled") ~= 0 then
+				forceload_on(pos, meta)
+			end
+		end
+		set_display(pos, meta)
+	end,
+	mesecons = {
+		effector = {
+			action_on = function(pos)
+				local meta = minetest.get_meta(pos)
+				meta:set_int("enabled", 1)
+				forceload_on(pos, meta)
+				set_display(pos, meta)
+			end,
+			action_off = function(pos)
+				local meta = minetest.get_meta(pos)
+				meta:set_int("enabled", 0)
+				forceload_off(meta)
+				set_display(pos, meta)
+			end
+		}
+	}
+})

mods/technic_plus/technic/machines/other/coal_alloy_furnace.lua

@@ -0,0 +1,176 @@
+
+-- Fuel driven alloy furnace. This uses no EUs:
+
+local S = technic.getter
+
+minetest.register_craft({
+	output = 'technic:coal_alloy_furnace',
+	recipe = {
+		{'default:brick', 'default:brick', 'default:brick'},
+		{'default:brick', '',              'default:brick'},
+		{'default:brick', 'default:brick', 'default:brick'},
+	}
+})
+
+local machine_name = S("Fuel-Fired Alloy Furnace")
+local formspec =
+	"size[8,9]"..
+	"label[0,0;"..machine_name.."]"..
+	"image[2,2;1,1;default_furnace_fire_bg.png]"..
+	"list[context;fuel;2,3;1,1;]"..
+	"list[context;src;2,1;2,1;]"..
+	"list[context;dst;5,1;2,2;]"..
+	"list[current_player;main;0,5;8,4;]"..
+	"listring[context;dst]"..
+	"listring[current_player;main]"..
+	"listring[context;src]"..
+	"listring[current_player;main]"..
+	"listring[context;fuel]"..
+	"listring[current_player;main]"
+
+minetest.register_node("technic:coal_alloy_furnace", {
+	description = machine_name,
+	tiles = {"technic_coal_alloy_furnace_top.png",  "technic_coal_alloy_furnace_bottom.png",
+	         "technic_coal_alloy_furnace_side.png", "technic_coal_alloy_furnace_side.png",
+	         "technic_coal_alloy_furnace_side.png", "technic_coal_alloy_furnace_front.png"},
+	paramtype2 = "facedir",
+	groups = {cracky=2},
+	legacy_facedir_simple = true,
+	sounds = default.node_sound_stone_defaults(),
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("formspec", formspec)
+		meta:set_string("infotext", machine_name)
+		local inv = meta:get_inventory()
+		inv:set_size("fuel", 1)
+		inv:set_size("src", 2)
+		inv:set_size("dst", 4)
+	end,
+	can_dig = technic.machine_can_dig,
+	allow_metadata_inventory_put = technic.machine_inventory_put,
+	allow_metadata_inventory_take = technic.machine_inventory_take,
+	allow_metadata_inventory_move = technic.machine_inventory_move,
+})
+
+minetest.register_node("technic:coal_alloy_furnace_active", {
+	description = machine_name,
+	tiles = {"technic_coal_alloy_furnace_top.png",  "technic_coal_alloy_furnace_bottom.png",
+	         "technic_coal_alloy_furnace_side.png", "technic_coal_alloy_furnace_side.png",
+	         "technic_coal_alloy_furnace_side.png", "technic_coal_alloy_furnace_front_active.png"},
+	paramtype2 = "facedir",
+	light_source = 8,
+	drop = "technic:coal_alloy_furnace",
+	groups = {cracky=2, not_in_creative_inventory=1},
+	legacy_facedir_simple = true,
+	sounds = default.node_sound_stone_defaults(),
+	can_dig = technic.machine_can_dig,
+	allow_metadata_inventory_put = technic.machine_inventory_put,
+	allow_metadata_inventory_take = technic.machine_inventory_take,
+	allow_metadata_inventory_move = technic.machine_inventory_move,
+})
+
+minetest.register_abm({
+	label = "Machines: run coal alloy furnace",
+	nodenames = {"technic:coal_alloy_furnace", "technic:coal_alloy_furnace_active"},
+	interval = 1,
+	chance = 1,
+	action = function(pos, node, active_object_count, active_object_count_wider)
+		local meta = minetest.get_meta(pos)
+		local inv    = meta:get_inventory()
+
+		if inv:get_size("src") == 1 then -- Old furnace -> convert it
+			inv:set_size("src", 2)
+			inv:set_stack("src", 2, inv:get_stack("src2", 1))
+			inv:set_size("src2", 0)
+		end
+
+		for i, name in pairs({
+				"fuel_totaltime",
+				"fuel_time",
+				"src_totaltime",
+				"src_time"}) do
+			if not meta:get_float(name) then
+				meta:set_float(name, 0.0)
+			end
+		end
+
+		-- Get what to cook if anything
+		local result = technic.get_recipe("alloy", inv:get_list("src"))
+
+		local was_active = false
+
+		if meta:get_float("fuel_time") < meta:get_float("fuel_totaltime") then
+			was_active = true
+			meta:set_int("fuel_time", meta:get_int("fuel_time") + 1)
+			if result then
+				meta:set_int("src_time", meta:get_int("src_time") + 1)
+				if meta:get_int("src_time") >= result.time then
+					meta:set_int("src_time", 0)
+					local result_stack = ItemStack(result.output)
+					if inv:room_for_item("dst", result_stack) then
+						inv:set_list("src", result.new_input)
+						inv:add_item("dst", result_stack)
+					end
+				end
+			else
+				meta:set_int("src_time", 0)
+			end
+		end
+
+		if meta:get_float("fuel_time") < meta:get_float("fuel_totaltime") then
+			local percent = math.floor(meta:get_float("fuel_time") /
+					meta:get_float("fuel_totaltime") * 100)
+			meta:set_string("infotext", S("%s Active"):format(machine_name).." ("..percent.."%)")
+			technic.swap_node(pos, "technic:coal_alloy_furnace_active")
+			meta:set_string("formspec",
+					"size[8,9]"..
+					"label[0,0;"..machine_name.."]"..
+					"image[2,2;1,1;default_furnace_fire_bg.png^[lowpart:"..
+					(100 - percent)..":default_furnace_fire_fg.png]"..
+					"list[context;fuel;2,3;1,1;]"..
+					"list[context;src;2,1;2,1;]"..
+					"list[context;dst;5,1;2,2;]"..
+					"list[current_player;main;0,5;8,4;]"..
+					"listring[context;dst]"..
+					"listring[current_player;main]"..
+					"listring[context;src]"..
+					"listring[current_player;main]"..
+					"listring[context;fuel]"..
+					"listring[current_player;main]")
+			return
+		end
+
+		local recipe = technic.get_recipe("alloy", inv:get_list("src"))
+
+		if not recipe then
+			if was_active then
+				meta:set_string("infotext", S("%s is empty"):format(machine_name))
+				technic.swap_node(pos, "technic:coal_alloy_furnace")
+				meta:set_string("formspec", formspec)
+			end
+			return
+		end
+
+		-- Next take a hard look at the fuel situation
+		local fuel = nil
+		local afterfuel
+		local fuellist = inv:get_list("fuel")
+
+		if fuellist then
+			fuel, afterfuel = minetest.get_craft_result({method = "fuel", width = 1, items = fuellist})
+		end
+
+		if fuel.time <= 0 then
+			meta:set_string("infotext", S("%s Out Of Fuel"):format(machine_name))
+			technic.swap_node(pos, "technic:coal_alloy_furnace")
+			meta:set_string("formspec", formspec)
+			return
+		end
+
+		meta:set_string("fuel_totaltime", fuel.time)
+		meta:set_string("fuel_time", 0)
+
+		inv:set_stack("fuel", 1, afterfuel.items[1])
+	end,
+})
+

mods/technic_plus/technic/machines/other/coal_furnace.lua

@@ -0,0 +1,5 @@
+local S = technic.getter
+
+if minetest.registered_nodes["default:furnace"].description == "Furnace" then
+	minetest.override_item("default:furnace", { description = S("Fuel-Fired Furnace") })
+end

mods/technic_plus/technic/machines/other/constructor.lua

@@ -0,0 +1,210 @@
+
+local S = technic.getter
+
+local function deploy_node(inv, slot_name, pos, node, machine_node)
+	if node.param2 > 3 then return end
+	if node.name ~= "air" then
+		if node.name == "ignore" or
+		   node.name == "default:chest_open" or
+		   node.name == "default:chest_locked_open" or
+		   node.name == "default:lava_source" or
+		   node.name == "default:lava_flowing" or
+		   node.name == "default:water_source" or
+		   node.name == "default:water_flowing" then
+			return
+		end
+		local drops = minetest.get_node_drops(node.name, "")
+		local remove_to = false
+		for i, item in ipairs(drops) do
+			if not inv:room_for_item(slot_name, item) then
+				remove_to = i - 1
+				break
+			end
+			inv:add_item(slot_name, item)
+		end
+		if remove_to then
+			for i = 1, remove_to do
+				inv:remove_item(slot_name, drops[i])
+			end
+		else
+			minetest.remove_node(pos)
+		end
+		return
+	end
+	if not inv:is_empty(slot_name) then
+		local stack = inv:get_list(slot_name)[1]
+		local def = stack:get_definition()
+		if def.type == "node" then
+			minetest.set_node(pos, {
+				name = stack:get_name(),
+				param2 = machine_node.param2
+			})
+			stack:take_item()
+			inv:set_stack(slot_name, 1, stack)
+		elseif def.type == "craft" then
+			if def.on_place then
+				-- Use pcall to avoid nil placer errors.
+				-- TODO: Do without pcall.
+				local ok, stk = pcall(def.on_place, stack, nil, {
+					-- Fake pointed_thing
+					type = "node",
+					above = pos,
+					under = {x=pos.x, y=pos.y-1, z=pos.z},
+				})
+				if ok then
+					inv:set_stack(slot_name, 1, stk or stack)
+					return
+				end
+			end
+			minetest.item_place_object(stack, nil, {
+				-- Fake pointed_thing
+				type = "node",
+				above = pos,
+				under = pos,
+			})
+			inv:set_stack(slot_name, 1, nil)
+		end
+	end
+end
+
+minetest.register_craft({
+	type = "shapeless",
+	output = 'technic:constructor_mk1_off 1',
+	recipe = {'technic:nodebreaker_off', 'technic:deployer_off'},
+
+})
+minetest.register_craft({
+	type = "shapeless",
+	output = 'technic:constructor_mk2_off 1',
+	recipe = {'technic:constructor_mk1_off', 'technic:constructor_mk1_off'},
+
+})
+
+minetest.register_craft({
+	type = "shapeless",
+	output = 'technic:constructor_mk3_off 1',
+	recipe = {'technic:constructor_mk2_off', 'technic:constructor_mk2_off'},
+
+})
+
+local function make_on(mark, length)
+	return function(pos, node)
+		local meta = minetest.get_meta(pos)
+		local owner = meta:get_string("owner")
+		local inv = meta:get_inventory()
+		local dir = vector.new()
+		if node.param2 == 3 then dir.x = 1 end
+		if node.param2 == 2 then dir.z = 1 end
+		if node.param2 == 1 then dir.x = -1 end
+		if node.param2 == 0 then dir.z = -1 end
+
+		local place_pos = vector.new(pos)
+
+		if node.name == "technic:constructor_mk"..mark.."_off" then
+			technic.swap_node(pos, "technic:constructor_mk"..mark.."_on")
+			minetest.check_for_falling(pos)
+			for i = 1, length do
+				place_pos = vector.add(place_pos, dir)
+				if owner ~= "" and minetest.is_protected(place_pos, owner) then
+					return
+				end
+				local place_node = minetest.get_node(place_pos)
+				deploy_node(inv, "slot"..i, place_pos, place_node, node)
+			end
+		end
+	end
+end
+
+local function make_off(mark)
+	return function(pos, node)
+		if node.name == "technic:constructor_mk"..mark.."_on" then
+			technic.swap_node(pos,"technic:constructor_mk"..mark.."_off")
+			minetest.check_for_falling(pos)
+		end
+	end
+end
+
+local function allow_inventory_put(pos, listname, index, stack, player)
+	if stack and minetest.get_item_group(stack:get_name(), "technic_constructor") == 1 then
+		return 0
+	end
+	return technic.machine_inventory_put(pos, listname, index, stack, player)
+end
+
+local function make_constructor(mark, length)
+	minetest.register_node("technic:constructor_mk"..mark.."_off", {
+		description = S("Constructor Mk%d"):format(mark),
+		tiles = {"technic_constructor_mk"..mark.."_top_off.png",
+			"technic_constructor_mk"..mark.."_bottom_off.png",
+			"technic_constructor_mk"..mark.."_side2_off.png",
+			"technic_constructor_mk"..mark.."_side1_off.png",
+			"technic_constructor_back.png",
+			"technic_constructor_front_off.png"},
+		paramtype2 = "facedir",
+		groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+			mesecon = 2, technic_constructor = 1},
+		mesecons = {effector = {action_on = make_on(mark, length)}},
+		sounds = default.node_sound_stone_defaults(),
+		on_construct = function(pos)
+			local meta = minetest.get_meta(pos)
+			local formspec = "size[8,9;]"..
+				"label[0,0;"..S("Constructor Mk%d"):format(mark).."]"..
+				"list[current_player;main;0,5;8,4;]"..
+				"listring[current_player;main]"
+			for i = 1, length do
+				formspec = formspec..
+					"label[5,"..(i - 1)..";"..S("Slot %d"):format(i).."]"..
+					"list[context;slot"..i..";6,"..(i - 1)..";1,1;]"..
+					"listring[context;slot"..i.."]"
+			end
+			meta:set_string("formspec", formspec)
+			meta:set_string("infotext", S("Constructor Mk%d"):format(mark))
+			local inv = meta:get_inventory()
+			for i = 1, length do
+				inv:set_size("slot"..i, 1)
+			end
+			meta:set_string("owner", "?")
+		end,
+		after_place_node = function(pos, placer)
+			local meta = minetest.get_meta(pos)
+			meta:set_string("owner", (placer and placer:get_player_name() or "?"))
+		end,
+		can_dig = function(pos, player)
+			local meta = minetest.get_meta(pos)
+			local inv = meta:get_inventory()
+			for i = 1, length do
+				if not inv:is_empty("slot"..i) then
+					return false
+				end
+			end
+			return true
+		end,
+		allow_metadata_inventory_put = allow_inventory_put,
+		allow_metadata_inventory_take = technic.machine_inventory_take,
+		allow_metadata_inventory_move = technic.machine_inventory_move,
+		on_rotate = screwdriver.rotate_simple
+	})
+
+	minetest.register_node("technic:constructor_mk"..mark.."_on", {
+		tiles = {"technic_constructor_mk"..mark.."_top_on.png",
+			"technic_constructor_mk"..mark.."_bottom_on.png",
+			"technic_constructor_mk"..mark.."_side2_on.png",
+			"technic_constructor_mk"..mark.."_side1_on.png",
+			"technic_constructor_back.png",
+			"technic_constructor_front_on.png"},
+		paramtype2 = "facedir",
+		drop = "technic:constructor_mk"..mark.."_off",
+		groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+			mesecon=2, not_in_creative_inventory=1, technic_constructor=1},
+		mesecons= {effector = {action_off = make_off(mark)}},
+		sounds = default.node_sound_stone_defaults(),
+		allow_metadata_inventory_put = allow_inventory_put,
+		allow_metadata_inventory_take = technic.machine_inventory_take,
+		allow_metadata_inventory_move = technic.machine_inventory_move,
+		on_rotate = false
+	})
+end
+
+make_constructor(1, 1)
+make_constructor(2, 2)
+make_constructor(3, 4)

mods/technic_plus/technic/machines/other/init.lua

@@ -0,0 +1,15 @@
+local path = technic.modpath.."/machines/other"
+
+-- mesecons and tubes related
+dofile(path.."/injector.lua")
+dofile(path.."/constructor.lua")
+
+if technic.config:get_bool("enable_frames") and minetest.get_modpath("mesecons_mvps") ~= nil then
+	dofile(path.."/frames.lua")
+end
+
+-- Coal-powered machines
+dofile(path.."/coal_alloy_furnace.lua")
+dofile(path.."/coal_furnace.lua")
+
+dofile(path.."/anchor.lua")

mods/technic_plus/technic/machines/other/injector.lua

@@ -0,0 +1,157 @@
+
+local S = technic.getter
+
+local fs_helpers = pipeworks.fs_helpers
+
+local tube_entry = "^pipeworks_tube_connection_metallic.png"
+
+local param2_to_under = {
+	[0] = {x= 0,y=-1,z= 0}, [1] = {x= 0,y= 0,z=-1},
+	[2] = {x= 0,y= 0,z= 1}, [3] = {x=-1,y= 0,z= 0},
+	[4] = {x= 1,y= 0,z= 0}, [5] = {x= 0,y= 1,z= 0}
+}
+
+local base_formspec = "size[8,9;]"..
+	"label[0,0;"..S("Self-Contained Injector").."]"..
+	"list[context;main;0,2;8,2;]"..
+	"list[current_player;main;0,5;8,4;]"..
+	"listring[]"
+
+local function set_injector_formspec(pos)
+	local meta = minetest.get_meta(pos)
+	local formspec = base_formspec..
+		fs_helpers.cycling_button(
+			meta,
+			pipeworks.button_base,
+			"splitstacks",
+			{
+				pipeworks.button_off,
+				pipeworks.button_on
+			}
+		)..pipeworks.button_label
+	if meta:get_string("mode") == "whole stacks" then
+		formspec = formspec.."button[0,1;4,1;mode_item;"..S("Stackwise").."]"
+	else
+		formspec = formspec.."button[0,1;4,1;mode_stack;"..S("Itemwise").."]"
+	end
+	if minetest.get_node_timer(pos):is_started() then
+		formspec = formspec.."button[4,1;4,1;disable;"..S("Enabled").."]"
+	else
+		formspec = formspec.."button[4,1;4,1;enable;"..S("Disabled").."]"
+	end
+	meta:set_string("formspec", formspec)
+end
+
+minetest.register_node("technic:injector", {
+	description = S("Self-Contained Injector"),
+	tiles = {
+		"technic_injector_top.png"..tube_entry,
+		"technic_injector_bottom.png",
+		"technic_injector_side.png"..tube_entry,
+		"technic_injector_side.png"..tube_entry,
+		"technic_injector_side.png"..tube_entry,
+		"technic_injector_side.png"
+	},
+	paramtype2 = "facedir",
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2, tubedevice=1, tubedevice_receiver=1},
+	tube = {
+		can_insert = function(pos, node, stack, direction)
+			local meta = minetest.get_meta(pos)
+			if meta:get_int("splitstacks") == 1 then
+				stack = stack:peek_item(1)
+			end
+			return meta:get_inventory():room_for_item("main", stack)
+		end,
+		insert_object = function(pos, node, stack, direction)
+			return minetest.get_meta(pos):get_inventory():add_item("main", stack)
+		end,
+		connect_sides = {left=1, right=1, back=1, top=1, bottom=1},
+	},
+	sounds = default.node_sound_wood_defaults(),
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("Self-Contained Injector"))
+		meta:set_string("mode", "single items")
+		meta:get_inventory():set_size("main", 16)
+		minetest.get_node_timer(pos):start(1)
+		set_injector_formspec(pos)
+	end,
+	can_dig = function(pos, player)
+		return minetest.get_meta(pos):get_inventory():is_empty("main")
+	end,
+	on_receive_fields = function(pos, formanme, fields, sender)
+		if fields.quit or not pipeworks.may_configure(pos, sender) then
+			return
+		end
+		local meta = minetest.get_meta(pos)
+		if fields.mode_item then
+			meta:set_string("mode", "single items")
+		elseif fields.mode_stack then
+			meta:set_string("mode", "whole stacks")
+		elseif fields.disable then
+			minetest.get_node_timer(pos):stop()
+		elseif fields.enable then
+			minetest.get_node_timer(pos):start(1)
+		end
+		fs_helpers.on_receive_fields(pos, fields)
+		set_injector_formspec(pos)
+	end,
+	on_timer = function(pos, elapsed)
+		local meta = minetest.get_meta(pos)
+		local node = minetest.get_node(pos)
+		local dir = param2_to_under[math.floor(node.param2 / 4)]
+		local node_under = minetest.get_node(vector.add(pos, dir))
+		if minetest.get_item_group(node_under.name, "tubedevice") > 0 then
+			local inv = meta:get_inventory()
+			local list = inv:get_list("main")
+			if not list then
+				return true
+			end
+			local stackwise = meta:get_string("mode") == "whole stacks"
+			for i,stack in ipairs(list) do
+				if not stack:is_empty() then
+					if stackwise then
+						technic.tube_inject_item(pos, pos, dir, stack:to_table())
+						stack:clear()
+					else
+						technic.tube_inject_item(pos, pos, dir, stack:take_item(1):to_table())
+					end
+					inv:set_stack("main", i, stack)
+					break
+				end
+			end
+		end
+		return true
+	end,
+	on_rotate = function(pos, node, user, mode, new_param2)
+		node.param2 = new_param2
+		minetest.swap_node(pos, node)
+		pipeworks.scan_for_tube_objects(pos)
+		return true
+	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,
+	after_place_node = pipeworks.after_place,
+	after_dig_node = pipeworks.after_dig
+})
+
+minetest.register_craft({
+	output = "technic:injector 1",
+	recipe = {
+		{"", "technic:control_logic_unit",""},
+		{"", "default:chest",""},
+		{"", "pipeworks:tube_1",""},
+	}
+})
+
+minetest.register_lbm({
+	label = "Old injector conversion",
+	name = "technic:old_injector_conversion",
+	nodenames = {"technic:injector"},
+	run_at_every_load = false,
+	action = function(pos, node)
+		minetest.get_node_timer(pos):start(1)
+		set_injector_formspec(pos)
+	end
+})

mods/technic_plus/technic/machines/power_monitor.lua

@@ -0,0 +1,130 @@
+-- POWER MONITOR
+-- The power monitor can be used to monitor how much power is available on a network,
+-- similarly to the old "slave" switching stations.
+
+local S = technic.getter
+
+local cable_entry = "^technic_cable_connection_overlay.png"
+
+-- Get registered cable or nil, returns nil if area is not loaded
+local function get_cable(pos)
+	local node = minetest.get_node_or_nil(pos)
+	return (node and technic.get_cable_tier(node.name)) and node
+end
+
+-- return the position of connected cable or nil
+-- TODO: Make it support every possible orientation
+local function get_connected_cable_network(pos)
+	local param2 = minetest.get_node(pos).param2
+	-- should probably also work sideways or upside down but for now it wont
+	if param2 > 3 then return end
+	-- Below?
+	local checkpos = {x=pos.x,y=pos.y-1,z=pos.z}
+	local network_id = get_cable(checkpos) and technic.pos2network(checkpos)
+	if network_id then
+		return network_id
+	end
+	-- Behind?
+	checkpos = vector.add(minetest.facedir_to_dir(param2),pos)
+	network_id = get_cable(checkpos) and technic.pos2network(checkpos)
+	return network_id
+end
+
+-- return the position of the associated switching station or nil
+local function get_network(pos)
+	local network_id = get_connected_cable_network(pos)
+	local network = network_id and technic.networks[network_id]
+	local swpos = network and technic.network2sw_pos(network_id)
+	local is_powermonitor = swpos and minetest.get_node(swpos).name == "technic:switching_station"
+	return (is_powermonitor and network.all_nodes[network_id]) and network
+end
+
+minetest.register_craft({
+	output = "technic:power_monitor",
+	recipe = {
+		{"",                 "",                       ""},
+		{"",                 "technic:machine_casing", "default:copper_ingot"},
+		{"technic:lv_cable", "technic:lv_cable",       "technic:lv_cable"}
+	}
+})
+
+minetest.register_node("technic:power_monitor",{
+	description = S("Power Monitor"),
+	tiles  = {
+		"technic_power_monitor_sides.png",
+		"technic_power_monitor_sides.png"..cable_entry,
+		"technic_power_monitor_sides.png",
+		"technic_power_monitor_sides.png",
+		"technic_power_monitor_sides.png"..cable_entry,
+		"technic_power_monitor_front.png"
+	},
+	paramtype2 = "facedir",
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2, technic_all_tiers=1},
+	connect_sides = {"bottom", "back"},
+	sounds = default.node_sound_wood_defaults(),
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("Power Monitor"))
+		meta:set_string("channel", "power_monitor"..minetest.pos_to_string(pos))
+		meta:set_string("formspec", "field[channel;Channel;${channel}]")
+	end,
+	on_receive_fields = function(pos, formname, fields, sender)
+		if not fields.channel then
+			return
+		end
+		local plname = sender:get_player_name()
+    if minetest.is_protected(pos, plname) and not minetest.check_player_privs(sender, "protection_bypass") then
+			minetest.record_protection_violation(pos, plname)
+			return
+		end
+		local meta = minetest.get_meta(pos)
+		meta:set_string("channel", fields.channel)
+	end,
+	digiline = {
+		receptor = {
+			rules = technic.digilines.rules,
+			action = function() end
+		},
+		effector = {
+			rules = technic.digilines.rules,
+			action = function(pos, node, channel, msg)
+				if msg ~= "GET" and msg ~= "get" then
+					return
+				end
+				local meta = minetest.get_meta(pos)
+				if channel ~= meta:get_string("channel") then
+					return
+				end
+
+				local network = get_network(pos)
+				if not network then return end
+
+				digilines.receptor_send(pos, technic.digilines.rules, channel, {
+					supply = network.supply,
+					demand = network.demand,
+					lag = network.lag,
+					battery_count = network.battery_count,
+					battery_charge = network.battery_charge,
+					battery_charge_max = network.battery_charge_max,
+				})
+			end
+		},
+	},
+})
+
+minetest.register_abm({
+	nodenames = {"technic:power_monitor"},
+	label = "Machines: run power monitor",
+	interval   = 1,
+	chance     = 1,
+	action = function(pos, node, active_object_count, active_object_count_wider)
+		local meta = minetest.get_meta(pos)
+		local network = get_network(pos)
+		if network then
+			meta:set_string("infotext", S("Power Monitor. Supply: @1 Demand: @2",
+					technic.EU_string(network.supply), technic.EU_string(network.demand)))
+		else
+			meta:set_string("infotext",S("Power Monitor Has No Network"))
+		end
+	end,
+})

mods/technic_plus/technic/machines/register/alloy_furnace.lua

@@ -0,0 +1,50 @@
+
+local S = technic.getter
+
+function technic.insert_object_unique_stack(pos, node, incoming_stack, direction)
+	local meta = minetest.get_meta(pos)
+	local inv = meta:get_inventory()
+	local incoming_name = incoming_stack:get_name()
+	local stack_index = nil
+	for inv_index, inv_stack in pairs(inv:get_list("src")) do
+		if inv_stack:get_name() == incoming_name then
+			stack_index = inv_index
+			break
+		end
+	end
+	if stack_index == nil then
+		return inv:add_item("src", incoming_stack)
+	end
+	local present_stack = inv:get_stack("src", stack_index)
+	local leftover = present_stack:add_item(incoming_stack)
+	inv:set_stack("src", stack_index, present_stack)
+	return leftover
+end
+
+function technic.can_insert_unique_stack(pos, node, incoming_stack, direction)
+	local meta = minetest.get_meta(pos)
+	local inv = meta:get_inventory()
+	local incoming_name = incoming_stack:get_name()
+	if meta:get_int("splitstacks") == 0 then
+		-- avoid looping second time with inv:contains_item("src", incoming_stack)
+		for _, inv_stack in pairs(inv:get_list("src")) do
+			if inv_stack:get_name() == incoming_name then
+				return inv_stack:item_fits(incoming_stack)
+			end
+		end
+	end
+
+	return technic.default_can_insert(pos, node, incoming_stack, direction)
+end
+
+function technic.register_alloy_furnace(data)
+	data.typename = "alloy"
+	data.machine_name = "alloy_furnace"
+	data.machine_desc = S("%s Alloy Furnace")
+
+	data.insert_object = technic.insert_object_unique_stack
+	data.can_insert = technic.can_insert_unique_stack
+
+	technic.register_base_machine(data)
+end
+

mods/technic_plus/technic/machines/register/alloy_recipes.lua

@@ -0,0 +1,44 @@
+
+local S = technic.getter
+
+technic.register_recipe_type("alloy", {
+	description = S("Alloying"),
+	input_size = 2,
+})
+
+function technic.register_alloy_recipe(data)
+	data.time = data.time or 6
+	technic.register_recipe("alloy", data)
+end
+
+local recipes = {
+	{"technic:copper_dust 7",         "technic:tin_dust",           "technic:bronze_dust 8", 12},
+	{"default:copper_ingot 7",        "default:tin_ingot",          "default:bronze_ingot 8", 12},
+	{"technic:wrought_iron_dust 2",   "technic:coal_dust",          "technic:carbon_steel_dust 2", 6},
+	{"technic:wrought_iron_ingot 2",  "technic:coal_dust",          "technic:carbon_steel_ingot 2", 6},
+	{"technic:carbon_steel_dust 2",   "technic:coal_dust",          "technic:cast_iron_dust 2", 6},
+	{"technic:carbon_steel_ingot 2",  "technic:coal_dust",          "technic:cast_iron_ingot 2", 6},
+	{"technic:carbon_steel_dust 4",   "technic:chromium_dust",      "technic:stainless_steel_dust 5", 7.5},
+	{"technic:carbon_steel_ingot 4",  "technic:chromium_ingot",     "technic:stainless_steel_ingot 5", 7.5},
+	{"technic:copper_dust 2",         "technic:zinc_dust",          "technic:brass_dust 3"},
+	{"default:copper_ingot 2",        "technic:zinc_ingot",         "basic_materials:brass_ingot 3"},
+	{"default:sand 2",                "technic:coal_dust 2",        "technic:silicon_wafer"},
+	{"technic:silicon_wafer",         "technic:gold_dust",          "technic:doped_silicon_wafer"},
+	-- from https://en.wikipedia.org/wiki/Carbon_black
+	-- The highest volume use of carbon black is as a reinforcing filler in rubber products, especially tires.
+	-- "[Compounding a] pure gum vulcanizate … with 50% of its weight of carbon black
+	-- improves its tensile strength and wear resistance …"
+	{"technic:raw_latex 4",           "technic:coal_dust 2",        "technic:rubber 6", 2},
+	{"default:ice", 		  	      "bucket:bucket_empty",        "bucket:bucket_water", 1 },
+	{"default:obsidian",			  "bucket:bucket_empty",        "bucket:bucket_lava", 1 },
+}
+
+if minetest.get_modpath("ethereal") then
+	table.insert(recipes, {"default:clay", "dye:red", "bakedclay:red"})
+	table.insert(recipes, {"default:clay", "dye:orange", "bakedclay:orange"})
+	table.insert(recipes, {"default:clay", "dye:grey", "bakedclay:grey"})
+end
+
+for _, data in pairs(recipes) do
+	technic.register_alloy_recipe({input = {data[1], data[2]}, output = data[3], time = data[4]})
+end

mods/technic_plus/technic/machines/register/battery_box.lua

@@ -0,0 +1,431 @@
+
+local digilines_path = minetest.get_modpath("digilines")
+
+local S = technic.getter
+local tube_entry = "^pipeworks_tube_connection_metallic.png"
+local cable_entry = "^technic_cable_connection_overlay.png"
+
+technic.register_power_tool("technic:battery", 10000)
+technic.register_power_tool("technic:red_energy_crystal", 50000)
+technic.register_power_tool("technic:green_energy_crystal", 150000)
+technic.register_power_tool("technic:blue_energy_crystal", 450000)
+
+-- Battery recipes:
+-- Tin-copper recipe:
+minetest.register_craft({
+	output = "technic:battery",
+	recipe = {
+		{"group:wood", "default:copper_ingot", "group:wood"},
+		{"group:wood", "default:tin_ingot",    "group:wood"},
+		{"group:wood", "default:copper_ingot", "group:wood"},
+	}
+})
+-- Sulfur-lead-water recipes:
+-- With sulfur lumps:
+-- With water:
+minetest.register_craft({
+	output = "technic:battery",
+	recipe = {
+		{"group:wood",         "technic:sulfur_lump", "group:wood"},
+		{"technic:lead_ingot", "bucket:bucket_water", "technic:lead_ingot"},
+		{"group:wood",         "technic:sulfur_lump", "group:wood"},
+	},
+	replacements = {
+		{"bucket:bucket_water", "bucket:bucket_empty"}
+	}
+})
+-- With oil extract:
+minetest.register_craft({
+	output = "technic:battery",
+	recipe = {
+		{"group:wood",         "technic:sulfur_lump",   "group:wood"},
+		{"technic:lead_ingot", "homedecor:oil_extract", "technic:lead_ingot"},
+		{"group:wood",         "technic:sulfur_lump",   "group:wood"},
+	}
+})
+-- With sulfur dust:
+-- With water:
+minetest.register_craft({
+	output = "technic:battery",
+	recipe = {
+		{"group:wood",         "technic:sulfur_dust", "group:wood"},
+		{"technic:lead_ingot", "bucket:bucket_water", "technic:lead_ingot"},
+		{"group:wood",         "technic:sulfur_dust", "group:wood"},
+	},
+	replacements = {
+		{"bucket:bucket_water", "bucket:bucket_empty"}
+	}
+})
+-- With oil extract:
+minetest.register_craft({
+	output = "technic:battery",
+	recipe = {
+		{"group:wood",         "technic:sulfur_dust",   "group:wood"},
+		{"technic:lead_ingot", "homedecor:oil_extract", "technic:lead_ingot"},
+		{"group:wood",         "technic:sulfur_dust",   "group:wood"},
+	}
+})
+
+minetest.register_tool("technic:battery", {
+	description = S("RE Battery"),
+	inventory_image = "technic_battery.png",
+	wear_represents = "technic_RE_charge",
+	on_refill = technic.refill_RE_charge,
+	tool_capabilities = {
+		charge = 0,
+		max_drop_level = 0,
+		groupcaps = {
+			fleshy = {times={}, uses=10000, maxlevel=0}
+		}
+	}
+})
+
+-- x+2 + (z+2)*2
+local dirtab = {
+	[4] = 2,
+	[5] = 3,
+	[7] = 1,
+	[8] = 0
+}
+
+local tube = {
+	insert_object = function(pos, node, stack, direction)
+		if direction.y == 1
+			or (direction.y == 0 and dirtab[direction.x+2+(direction.z+2)*2] == node.param2) then
+			return stack
+		end
+		local meta = minetest.get_meta(pos)
+		local inv = meta:get_inventory()
+		if direction.y == 0 then
+			return inv:add_item("src", stack)
+		else
+			return inv:add_item("dst", stack)
+		end
+	end,
+	can_insert = function(pos, node, stack, direction)
+		if direction.y == 1
+			or (direction.y == 0 and dirtab[direction.x+2+(direction.z+2)*2] == node.param2) then
+			return false
+		end
+		local meta = minetest.get_meta(pos)
+		local inv = meta:get_inventory()
+		if direction.y == 0 then
+			return inv:room_for_item("src", stack)
+		else
+			return inv:room_for_item("dst", stack)
+		end
+	end,
+	connect_sides = {left=1, right=1, back=1, top=1},
+}
+
+function technic.register_battery_box(data)
+	local tier = data.tier
+	local ltier = string.lower(tier)
+	local formspec =
+		"size[8,9]"..
+		"image[1,1;1,2;technic_power_meter_bg.png]"..
+		"list[context;src;3,1;1,1;]"..
+		"image[4,1;1,1;technic_battery_reload.png]"..
+		"list[context;dst;5,1;1,1;]"..
+		"label[0,0;"..S("%s Battery Box"):format(tier).."]"..
+		"label[3,0;"..S("Charge").."]"..
+		"label[5,0;"..S("Discharge").."]"..
+		"label[1,3;"..S("Power level").."]"..
+		"list[current_player;main;0,5;8,4;]"..
+		"listring[context;dst]"..
+		"listring[current_player;main]"..
+		"listring[context;src]"..
+		"listring[current_player;main]"..
+		(data.upgrade and
+			"list[context;upgrade1;3.5,3;1,1;]"..
+			"list[context;upgrade2;4.5,3;1,1;]"..
+			"label[3.5,4;"..S("Upgrade Slots").."]"..
+			"listring[context;upgrade1]"..
+			"listring[current_player;main]"..
+			"listring[context;upgrade2]"..
+			"listring[current_player;main]"
+		or "")
+
+	--
+	-- Generate formspec with power meter
+	--
+	local function get_formspec(charge_ratio, channel)
+		return formspec .. "image[1,1;1,2;technic_power_meter_bg.png^[lowpart:" ..
+			math.floor(charge_ratio * 100) .. ":technic_power_meter_fg.png]" ..
+			(digilines_path and
+				("field[0.3,4;2.2,1;channel;Digiline channel;%s]button[2,3.7;1,1;setchannel;Set]")
+				:format(minetest.formspec_escape(channel))
+			or "")
+
+	end
+
+	--
+	-- Update fields not affecting internal network calculations and behavior in any way
+	--
+	local function update_node(pos, update_formspec)
+		-- Read metadata and calculate actual values based on upgrades
+		local meta = minetest.get_meta(pos)
+		local current_charge = meta:get_int("internal_EU_charge")
+		local EU_upgrade = 0
+		if data.upgrade then
+			EU_upgrade = technic.handle_machine_upgrades(meta)
+		end
+		local max_charge = data.max_charge * (1 + EU_upgrade / 10)
+		-- Select node textures
+		local charge_ratio = current_charge / max_charge
+		local charge_count = math.ceil(charge_ratio * 8)
+		charge_count = math.min(charge_count, 8)
+		charge_count = math.max(charge_count, 0)
+		local last_count = meta:get_float("last_side_shown")
+		if charge_count ~= last_count then
+			technic.swap_node(pos, "technic:" .. ltier .. "_battery_box" .. charge_count)
+			meta:set_float("last_side_shown", charge_count)
+		end
+		-- Update formspec and infotext
+		local eu_input = meta:get_int(tier.."_EU_input")
+		local infotext = S("@1 Battery Box: @2 / @3", tier,
+			technic.EU_string(current_charge), technic.EU_string(max_charge))
+		if eu_input == 0 then
+			infotext = S("%s Idle"):format(infotext)
+		end
+		meta:set_string("infotext", infotext)
+		if update_formspec then
+			local channel = meta:get_string("channel")
+			meta:set_string("formspec", get_formspec(charge_ratio, channel))
+		end
+	end
+
+	local function get_tool(inventory, listname)
+		-- Get itemstack and check if it is registered tool
+		if inventory:is_empty(listname) then
+			return
+		end
+		local toolstack = inventory:get_stack(listname, 1)
+		local toolname = toolstack:get_name()
+		if technic.power_tools[toolname] == nil then
+			return
+		end
+		local tooldef = toolstack:get_definition()
+		if not tooldef then
+			return
+		end
+		return toolstack, tooldef
+	end
+
+	local function charge_tools(meta, batt_charge, charge_step)
+		if batt_charge <= 0 then
+			return batt_charge, false
+		end
+		-- Get tool stack and definition
+		local inv = meta:get_inventory()
+		local toolstack, tooldef = get_tool(inv, "src")
+		if not toolstack then return batt_charge, false end
+		-- Do the charging, get and check
+		local get_charge = tooldef.technic_get_charge or technic.get_charge
+		local tool_charge, max_charge = get_charge(toolstack)
+		if tool_charge >= max_charge then
+			return batt_charge, true
+		end
+		-- Do the charging, set charge and replace stack
+		local set_charge = tooldef.technic_set_charge or technic.set_charge
+		charge_step = math.min(charge_step, batt_charge)
+		charge_step = math.min(charge_step, max_charge - tool_charge)
+		tool_charge = tool_charge + charge_step
+		set_charge(toolstack, tool_charge)
+		inv:set_stack("src", 1, toolstack)
+		return batt_charge - charge_step, (tool_charge == max_charge)
+	end
+
+	local function discharge_tools(meta, batt_charge, charge_step, batt_max_charge)
+		if batt_charge >= batt_max_charge then
+			return batt_charge, false
+		end
+		-- Get tool stack and definition
+		local inv = meta:get_inventory()
+		local toolstack, tooldef = get_tool(inv, "dst")
+		if not toolstack then return batt_charge, false end
+		-- Do the discharging, get and check
+		local get_charge = tooldef.technic_get_charge or technic.get_charge
+		local tool_charge = get_charge(toolstack)
+		if tool_charge <= 0 then
+			return batt_charge, true
+		end
+		-- Do the discharging, set charge and replace stack
+		local set_charge = tooldef.technic_set_charge or technic.set_charge
+		charge_step = math.min(charge_step, batt_max_charge - batt_charge)
+		charge_step = math.min(charge_step, tool_charge)
+		tool_charge = tool_charge - charge_step
+		set_charge(toolstack, tool_charge)
+		inv:set_stack("dst", 1, toolstack)
+		return batt_charge + charge_step, (tool_charge == 0)
+	end
+
+	local function run(pos, node, run_state, network)
+		local meta  = minetest.get_meta(pos)
+
+		local eu_input       = meta:get_int(tier.."_EU_input")
+		local current_charge = meta:get_int("internal_EU_charge")
+
+		local EU_upgrade, tube_upgrade = 0, 0
+		if data.upgrade then
+			EU_upgrade, tube_upgrade = technic.handle_machine_upgrades(meta)
+		end
+		local max_charge = data.max_charge * (1 + EU_upgrade / 10)
+
+		-- Charge/discharge the battery with the input EUs
+		if eu_input >= 0 then
+			current_charge = math.min(current_charge + eu_input, max_charge)
+		else
+			current_charge = math.max(current_charge + eu_input, 0)
+		end
+
+		-- Charging/discharging tools here
+		local tool_full, tool_empty
+		current_charge, tool_full = charge_tools(meta, current_charge, data.charge_step)
+		current_charge, tool_empty = discharge_tools(meta, current_charge, data.discharge_step, max_charge)
+
+		if data.tube and (tool_full or tool_empty) then
+			technic.handle_machine_pipeworks(pos, tube_upgrade, function(pos2, x_velocity, z_velocity)
+				if tool_full then
+					technic.send_items(pos2, x_velocity, z_velocity, "src")
+				elseif tool_empty then
+					technic.send_items(pos2, x_velocity, z_velocity, "dst")
+				end
+			end)
+		end
+
+		-- We allow batteries to charge on less than the demand
+		local supply = math.min(data.discharge_rate, current_charge)
+		local demand = math.min(data.charge_rate, max_charge - current_charge)
+		network:update_battery(current_charge, max_charge, supply, demand)
+
+		meta:set_int(tier.."_EU_demand", demand)
+		meta:set_int(tier.."_EU_supply", supply)
+		meta:set_int("internal_EU_charge", current_charge)
+		meta:set_int("internal_EU_charge_max", max_charge)
+
+		local timer = minetest.get_node_timer(pos)
+		if not timer:is_started() then
+			timer:start(2)
+		end
+	end
+
+	local function on_timer(pos, elapsed)
+		if not technic.pos2network(pos) then return end
+		update_node(pos)
+		return true
+	end
+
+	for i = 0, 8 do
+		local groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+				technic_machine=1, ["technic_"..ltier]=1}
+		if i ~= 0 then
+			groups.not_in_creative_inventory = 1
+		end
+
+		if data.tube then
+			groups.tubedevice = 1
+			groups.tubedevice_receiver = 1
+		end
+
+		local top_tex = "technic_"..ltier.."_battery_box_top.png"..tube_entry
+		local front_tex = "technic_"..ltier.."_battery_box_front.png^technic_power_meter"..i..".png"
+		local side_tex = "technic_"..ltier.."_battery_box_side.png"..tube_entry
+		local bottom_tex = "technic_"..ltier.."_battery_box_bottom.png"..cable_entry
+
+		if ltier == "lv" then
+			top_tex = "technic_"..ltier.."_battery_box_top.png"
+			front_tex = "technic_"..ltier.."_battery_box_side.png^technic_power_meter"..i..".png"
+			side_tex = "technic_"..ltier.."_battery_box_side.png^technic_power_meter"..i..".png"
+		end
+
+		minetest.register_node("technic:"..ltier.."_battery_box"..i, {
+			description = S("%s Battery Box"):format(tier),
+			tiles = {
+				top_tex,
+				bottom_tex,
+				side_tex,
+				side_tex,
+				side_tex,
+				front_tex},
+			groups = groups,
+			connect_sides = {"bottom"},
+			tube = data.tube and tube or nil,
+			paramtype2 = "facedir",
+			sounds = default.node_sound_wood_defaults(),
+			drop = "technic:"..ltier.."_battery_box0",
+			on_construct = function(pos)
+				local meta = minetest.get_meta(pos)
+				meta:set_string("infotext", S("%s Battery Box"):format(tier))
+				meta:set_int(tier.."_EU_demand", 0)
+				meta:set_int(tier.."_EU_supply", 0)
+				meta:set_int(tier.."_EU_input",  0)
+				meta:set_float("internal_EU_charge", 0)
+				local inv = meta:get_inventory()
+				inv:set_size("src", 1)
+				inv:set_size("dst", 1)
+				inv:set_size("upgrade1", 1)
+				inv:set_size("upgrade2", 1)
+				update_node(pos, true)
+			end,
+			can_dig = technic.machine_can_dig,
+			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,
+			on_timer = on_timer,
+			on_rightclick = function(pos) update_node(pos, true) end,
+			on_rotate = screwdriver.rotate_simple,
+			after_place_node = data.tube and pipeworks.after_place,
+			after_dig_node = technic.machine_after_dig_node,
+			on_receive_fields = function(pos, formname, fields, player)
+				local name = player:get_player_name()
+				if minetest.is_protected(pos, name) then
+					minetest.record_protection_violation(pos, name)
+					return
+				elseif fields.setchannel then
+					local meta = minetest.get_meta(pos)
+					meta:set_string("channel", fields.channel or "")
+					update_node(pos, true)
+				end
+			end,
+			digiline = {
+				receptor = {
+					rules = technic.digilines.rules,
+					action = function() end
+				},
+				effector = {
+					rules = technic.digilines.rules,
+					action = function(pos, node, channel, msg)
+						if msg ~= "GET" and msg ~= "get" then
+							return
+						end
+						local meta = minetest.get_meta(pos)
+						if channel ~= meta:get_string("channel") then
+							return
+						end
+						local inv = meta:get_inventory()
+						digilines.receptor_send(pos, technic.digilines.rules, channel, {
+							demand = meta:get_int(tier.."_EU_demand"),
+							supply = meta:get_int(tier.."_EU_supply"),
+							input  = meta:get_int(tier.."_EU_input"),
+							charge = meta:get_int("internal_EU_charge"),
+							max_charge = data.max_charge * (1 + technic.handle_machine_upgrades(meta) / 10),
+							src      = inv:get_stack("src", 1):to_table(),
+							dst      = inv:get_stack("dst", 1):to_table(),
+							upgrade1 = inv:get_stack("upgrade1", 1):to_table(),
+							upgrade2 = inv:get_stack("upgrade2", 1):to_table()
+						})
+					end
+				},
+			},
+		})
+	end
+
+	-- Register as a battery type
+	-- Battery type machines function as power reservoirs and can both receive and give back power
+	for i = 0, 8 do
+		technic.register_machine(tier, "technic:"..ltier.."_battery_box"..i, technic.battery)
+	end
+
+end -- End registration

mods/technic_plus/technic/machines/register/cables.lua

@@ -0,0 +1,355 @@
+
+local S = technic.getter
+
+local cable_tier = {}
+
+function technic.is_tier_cable(name, tier)
+	return cable_tier[name] == tier
+end
+
+function technic.get_cable_tier(name)
+	return cable_tier[name]
+end
+
+local function match_cable_tier_filter(name, tiers)
+	-- Helper to check for set of cable tiers
+	if tiers then
+		for _, tier in ipairs(tiers) do if cable_tier[name] == tier then return true end end
+		return false
+	end
+	return cable_tier[name] ~= nil
+end
+
+local function get_neighbors(pos, tiers)
+	-- TODO: Move this to network.lua
+	local tier_machines = tiers and technic.machines[tiers[1]]
+	local is_cable = match_cable_tier_filter(minetest.get_node(pos).name, tiers)
+	local network = is_cable and technic.networks[technic.pos2network(pos)]
+	local cables = {}
+	local machines = {}
+	local positions = {
+		{x=pos.x+1, y=pos.y,   z=pos.z},
+		{x=pos.x-1, y=pos.y,   z=pos.z},
+		{x=pos.x,   y=pos.y+1, z=pos.z},
+		{x=pos.x,   y=pos.y-1, z=pos.z},
+		{x=pos.x,   y=pos.y,   z=pos.z+1},
+		{x=pos.x,   y=pos.y,   z=pos.z-1},
+	}
+	for _,connected_pos in ipairs(positions) do
+		local name = minetest.get_node(connected_pos).name
+		if tier_machines and tier_machines[name] then
+			table.insert(machines, connected_pos)
+		elseif match_cable_tier_filter(name, tiers) then
+			local cable_network = technic.networks[technic.pos2network(connected_pos)]
+			table.insert(cables,{
+				pos = connected_pos,
+				network = cable_network,
+			})
+			if not network then network = cable_network end
+		end
+	end
+	return network, cables, machines
+end
+
+local function place_network_node(pos, tiers, name)
+	-- Get connections and primary network if there's any
+	local network, cables, machines = get_neighbors(pos, tiers)
+	if not network then
+		-- We're evidently not on a network, nothing to add ourselves to
+		return
+	end
+
+	-- Attach to primary network, this must be done before building branches from this position
+	technic.add_network_node(pos, network)
+	if not match_cable_tier_filter(name, tiers) then
+		if technic.machines[tiers[1]][name] == technic.producer_receiver then
+			-- FIXME: Multi tier machine like supply converter should also attach to other networks around pos.
+			--      Preferably also with connection rules defined for machine.
+			--      nodedef.connect_sides could be used to generate these rules.
+			--		For now, assume that all multi network machines belong to technic.producer_receiver group:
+			-- Get cables and networks around PR_RE machine
+			local _, machine_cables, _ = get_neighbors(pos)
+			for _,connection in ipairs(machine_cables) do
+				if connection.network and connection.network.id ~= network.id then
+					-- Attach PR_RE machine to secondary networks (last added is primary until above note is resolved)
+					technic.add_network_node(pos, connection.network)
+				end
+			end
+		else
+			-- Check connected cables for foreign networks, overload if machine was connected to multiple networks
+			for _, connection in ipairs(cables) do
+				if connection.network and connection.network.id ~= network.id then
+					technic.overload_network(connection.network.id)
+					technic.overload_network(network.id)
+				end
+			end
+		end
+		-- Machine added, skip all network building
+		return
+	end
+
+	-- Attach neighbor machines if cable was added
+	for _,machine_pos in ipairs(machines) do
+		technic.add_network_node(machine_pos, network)
+	end
+
+	-- Attach neighbor cables
+	for _,connection in ipairs(cables) do
+		if connection.network then
+			if connection.network.id ~= network.id then
+				-- Remove network if position belongs to another network
+				-- FIXME: Network requires partial rebuild but avoid doing it here if possible.
+				-- This might cause problems when merging two active networks into one
+				technic.remove_network(network.id)
+				technic.remove_network(connection.network.id)
+				connection.network = nil
+			end
+		else
+			-- There's cable that does not belong to any network, attach whole branch
+			technic.add_network_node(connection.pos, network)
+			technic.add_network_branch({connection.pos}, network)
+		end
+	end
+end
+-- NOTE: Exported for tests but should probably be moved to network.lua
+technic.network_node_on_placenode = place_network_node
+
+local function remove_network_node(pos, tiers, name)
+	-- Get the network and neighbors
+	local network, cables, machines = get_neighbors(pos, tiers)
+	if not network then return end
+
+	if not match_cable_tier_filter(name, tiers) then
+		-- Machine removed, skip cable checks to prevent unnecessary network cleanups
+		for _,connection in ipairs(cables) do
+			if connection.network then
+				-- Remove machine from all networks around it
+				technic.remove_network_node(connection.network.id, pos)
+			end
+		end
+		return
+	end
+
+	if #cables == 1 then
+		-- Dead end cable removed, remove it from the network
+		technic.remove_network_node(network.id, pos)
+		-- Remove neighbor machines from network if cable was removed
+		if match_cable_tier_filter(name, tiers) then
+			for _,machine_pos in ipairs(machines) do
+				local net, _, _ = get_neighbors(machine_pos, tiers)
+				if not net then
+					-- Remove machine from network if it does not have other connected cables
+					technic.remove_network_node(network.id, machine_pos)
+				end
+			end
+		end
+	else
+		-- TODO: Check branches around and switching stations for branches:
+		--   remove branches that do not have switching station. Switching stations not tracked but could be easily tracked.
+		--   remove branches not connected to another branch. Individual branches not tracked, requires simple AI heuristics.
+		--   move branches that have switching station to new networks without checking or loading actual nodes in world.
+		--   To do all this network must be aware of individual branches and switching stations, might not be worth it...
+		-- For now remove whole network and let ABM rebuild it
+		technic.remove_network(network.id)
+	end
+end
+-- NOTE: Exported for tests but should probably be moved to network.lua
+technic.network_node_on_dignode = remove_network_node
+
+local function item_place_override_node(itemstack, placer, pointed, node)
+	-- Call the default on_place function with a fake itemstack
+	local temp_itemstack = ItemStack(itemstack)
+	temp_itemstack:set_name(node.name)
+	local original_count = temp_itemstack:get_count()
+	temp_itemstack =
+		minetest.item_place(temp_itemstack, placer, pointed, node.param2) or
+		temp_itemstack
+	-- Remove the same number of items from the real itemstack
+	itemstack:take_item(original_count - temp_itemstack:get_count())
+	return itemstack
+end
+
+local function override_table(target, source)
+	if target and source then
+		for k,v in pairs(source) do
+			target[k] = v
+		end
+	end
+	return target
+end
+
+function technic.register_cable(tier, size, description, prefix, override_cable, override_cable_plate)
+	prefix = prefix or ""
+	override_cable_plate = override_cable_plate or override_cable
+	local ltier = string.lower(tier)
+	local node_name = "technic:"..ltier..prefix.."_cable"
+	cable_tier[node_name] = tier
+
+	local groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+			["technic_"..ltier.."_cable"] = 1}
+
+	local node_box = {
+		type = "connected",
+		fixed          = {-size, -size, -size, size,  size, size},
+		connect_top    = {-size, -size, -size, size,  0.5,  size}, -- y+
+		connect_bottom = {-size, -0.5,  -size, size,  size, size}, -- y-
+		connect_front  = {-size, -size, -0.5,  size,  size, size}, -- z-
+		connect_back   = {-size, -size,  size, size,  size, 0.5 }, -- z+
+		connect_left   = {-0.5,  -size, -size, size,  size, size}, -- x-
+		connect_right  = {-size, -size, -size, 0.5,   size, size}, -- x+
+	}
+
+	minetest.register_node(node_name, override_table({
+		description = S("%s Cable"):format(tier),
+		tiles = {"technic_"..ltier..prefix.."_cable.png"},
+		inventory_image = "technic_"..ltier..prefix.."_cable_wield.png",
+		wield_image = "technic_"..ltier..prefix.."_cable_wield.png",
+		groups = groups,
+		sounds = default.node_sound_wood_defaults(),
+		drop = node_name,
+		paramtype = "light",
+		sunlight_propagates = true,
+		drawtype = "nodebox",
+		node_box = node_box,
+		connects_to = {"group:technic_"..ltier.."_cable",
+			"group:technic_"..ltier, "group:technic_all_tiers"},
+		on_construct = function(pos) place_network_node(pos, {tier}, node_name) end,
+		on_destruct = function(pos) remove_network_node(pos, {tier}, node_name) end,
+	}, override_cable))
+
+	local xyz = {
+		["-x"] = 1,
+		["-y"] = 2,
+		["-z"] = 3,
+		["x"] = 4,
+		["y"] = 5,
+		["z"] = 6,
+	}
+	local notconnects = {
+		[1] = "left",
+		[2] = "bottom",
+		[3] = "front",
+		[4] = "right",
+		[5] = "top",
+		[6] = "back",
+	}
+	local function s(p)
+		if p:find("-") then
+			return p:sub(2)
+		else
+			return "-"..p
+		end
+	end
+	-- TODO: Does this really need 6 different nodes? Use single node for cable plate if possible.
+	for p, i in pairs(xyz) do
+		local def = {
+			description = S("%s Cable Plate"):format(tier),
+			tiles = {"technic_"..ltier..prefix.."_cable.png"},
+			groups = table.copy(groups),
+			sounds = default.node_sound_wood_defaults(),
+			drop = node_name .. "_plate_1",
+			paramtype = "light",
+			sunlight_propagates = true,
+			drawtype = "nodebox",
+			node_box = table.copy(node_box),
+			connects_to = {"group:technic_"..ltier.."_cable",
+				"group:technic_"..ltier, "group:technic_all_tiers"},
+			on_construct = function(pos) place_network_node(pos, {tier}, node_name.."_plate_"..i) end,
+			on_destruct = function(pos) remove_network_node(pos, {tier}, node_name.."_plate_"..i) end,
+		}
+		def.node_box.fixed = {
+			{-size, -size, -size, size, size, size},
+			{-0.5, -0.5, -0.5, 0.5, 0.5, 0.5}
+		}
+		def.node_box.fixed[1][xyz[p]] = 7/16 * (i-3.5)/math.abs(i-3.5)
+		def.node_box.fixed[2][xyz[s(p)]] = 3/8 * (i-3.5)/math.abs(i-3.5)
+		def.node_box["connect_"..notconnects[i]] = nil
+		if i == 1 then
+			def.on_place = function(itemstack, placer, pointed_thing)
+				local pointed_thing_diff = vector.subtract(pointed_thing.above, pointed_thing.under)
+				local num = 1
+				local changed
+				for k, v in pairs(pointed_thing_diff) do
+					if v ~= 0 then
+						changed = k
+						num = xyz[s(tostring(v):sub(-2, -2)..k)]
+						break
+					end
+				end
+				local crtl = placer:get_player_control()
+				if (crtl.aux1 or crtl.sneak) and not (crtl.aux1 and crtl.sneak) and changed then
+					local fine_pointed = minetest.pointed_thing_to_face_pos(placer, pointed_thing)
+					fine_pointed = vector.subtract(fine_pointed, pointed_thing.above)
+					fine_pointed[changed] = nil
+					local ps = {}
+					for p2, _ in pairs(fine_pointed) do
+						ps[#ps+1] = p2
+					end
+					local bigger = (math.abs(fine_pointed[ps[1]]) > math.abs(fine_pointed[ps[2]]) and ps[1]) or ps[2]
+					if math.abs(fine_pointed[bigger]) < 0.3 then
+						num = num + 3
+						num = (num <= 6 and num) or num - 6
+					else
+						num = xyz[((fine_pointed[bigger] < 0 and "-") or "") .. bigger]
+					end
+				end
+				if num == nil then num = 1 end
+				return item_place_override_node(
+					itemstack, placer, pointed_thing,
+					{name = node_name.."_plate_"..num}
+				)
+			end
+		else
+			def.groups.not_in_creative_inventory = 1
+		end
+		def.on_rotate = function(pos, node, user, mode, new_param2)
+			local dir = 0
+			if mode == screwdriver.ROTATE_FACE then -- left-click
+				dir = 1
+			elseif mode == screwdriver.ROTATE_AXIS then -- right-click
+				dir = -1
+			end
+			local num = tonumber(node.name:sub(-1))
+			num = num + dir
+			num = (num >= 1 and num) or num + 6
+			num = (num <= 6 and num) or num - 6
+			minetest.swap_node(pos, {name = node_name.."_plate_"..num})
+		end
+		minetest.register_node(node_name.."_plate_"..i, override_table(def, override_cable_plate))
+		cable_tier[node_name.."_plate_"..i] = tier
+	end
+
+	minetest.register_craft({
+		output = node_name.."_plate_1 5",
+		recipe = {
+			{""       , ""       , node_name},
+			{node_name, node_name, node_name},
+			{""       , ""       , node_name},
+		}
+	})
+
+	minetest.register_craft({
+		output = node_name,
+		recipe = {
+			{node_name.."_plate_1"},
+		}
+	})
+end
+
+minetest.register_on_mods_loaded(function()
+	-- FIXME: Move this to register.lua or somewhere else where register_on_mods_loaded is not required.
+	--        Possible better option would be to inject these when machine is registered in register.lua.
+	for name, tiers in pairs(technic.machine_tiers) do
+		local nodedef = minetest.registered_nodes[name]
+		local on_construct = type(nodedef.on_construct) == "function" and nodedef.on_construct
+		local on_destruct = type(nodedef.on_destruct) == "function" and nodedef.on_destruct
+		minetest.override_item(name,{
+			on_construct = on_construct
+				and function(pos) on_construct(pos) place_network_node(pos, tiers, name) end
+				or  function(pos) place_network_node(pos, tiers, name) end,
+			on_destruct = on_destruct
+				and function(pos) on_destruct(pos) remove_network_node(pos, tiers, name) end
+				or  function(pos) remove_network_node(pos, tiers, name) end,
+		})
+	end
+end)

mods/technic_plus/technic/machines/register/centrifuge.lua

@@ -0,0 +1,8 @@
+local S = technic.getter
+
+function technic.register_centrifuge(data)
+	data.typename = "separating"
+	data.machine_name = "centrifuge"
+	data.machine_desc = S("%s Centrifuge")
+	technic.register_base_machine(data)
+end

mods/technic_plus/technic/machines/register/centrifuge_recipes.lua

@@ -0,0 +1,48 @@
+local S = technic.getter
+
+technic.register_recipe_type("separating", {
+	description = S("Separating"),
+	output_size = 2,
+})
+
+function technic.register_separating_recipe(data)
+	data.time = data.time or 10
+	technic.register_recipe("separating", data)
+end
+
+local recipes = {
+	{ "technic:bronze_dust 8",             "technic:copper_dust 7",       "technic:tin_dust"      },
+	{ "technic:stainless_steel_dust 5",    "technic:wrought_iron_dust 4", "technic:chromium_dust" },
+	{ "technic:brass_dust 3",              "technic:copper_dust 2",       "technic:zinc_dust"     },
+	{ "technic:chernobylite_dust",         "default:sand",                "technic:uranium3_dust" },
+	{ "default:dirt 4",                    "default:sand",                "default:gravel",       "default:clay_lump 4" },
+}
+
+local function uranium_dust(p)
+	return "technic:uranium"..(p == 7 and "" or p).."_dust"
+end
+for p = 1, 34 do
+	table.insert(recipes, { uranium_dust(p).." 2", uranium_dust(p-1), uranium_dust(p+1) })
+end
+
+if minetest.get_modpath("bushes_classic") then
+	for _, berry in ipairs({ "blackberry", "blueberry", "gooseberry", "raspberry", "strawberry" }) do
+		table.insert(recipes, { "bushes:"..berry.."_bush", "default:stick 20", "bushes:"..berry.." 4" })
+	end
+end
+
+if minetest.get_modpath("farming") then
+	if minetest.get_modpath("cottages") then
+		-- work as a mechanized threshing floor
+		table.insert(recipes, { "farming:wheat", "farming:seed_wheat", "cottages:straw_mat" })
+		table.insert(recipes, { "farming:barley", "farming:seed_barley", "cottages:straw_mat" })
+	else
+		-- work in a less fancy and less efficient manner
+		table.insert(recipes, { "farming:wheat 4", "farming:seed_wheat 3", "default:dry_shrub 1" })
+		table.insert(recipes, { "farming:barley 4", "farming:seed_barley 3", "default:dry_shrub 1" })
+	end
+end
+
+for _, data in pairs(recipes) do
+	technic.register_separating_recipe({ input = { data[1] }, output = { data[2], data[3], data[4] } })
+end

mods/technic_plus/technic/machines/register/common.lua

@@ -0,0 +1,211 @@
+
+local S = technic.getter
+
+-- handles the machine upgrades every tick
+function technic.handle_machine_upgrades(meta)
+	-- Get the names of the upgrades
+	local inv = meta:get_inventory()
+
+	local srcstack = inv:get_stack("upgrade1", 1)
+	local upg_item1 = srcstack and srcstack:get_name()
+
+	srcstack = inv:get_stack("upgrade2", 1)
+	local upg_item2 = srcstack and srcstack:get_name()
+
+	-- Save some power by installing battery upgrades.
+	-- Tube loading speed can be upgraded using control logic units.
+	local EU_upgrade = 0
+	local tube_upgrade = 0
+
+	if upg_item1 == "technic:control_logic_unit" then
+		tube_upgrade = tube_upgrade + 1
+	elseif upg_item1 == "technic:battery" then
+		EU_upgrade = EU_upgrade + 1
+	end
+
+	if upg_item2 == "technic:control_logic_unit" then
+		tube_upgrade = tube_upgrade + 1
+	elseif  upg_item2 == "technic:battery" then
+		EU_upgrade = EU_upgrade + 1
+	end
+
+	return EU_upgrade, tube_upgrade
+end
+
+-- handles the machine upgrades when set or removed
+local function on_machine_upgrade(meta, stack)
+	local stack_name = stack:get_name()
+	if stack_name == "default:chest" then
+		meta:set_int("public", 1)
+		return 1
+	elseif stack_name ~= "technic:control_logic_unit"
+	   and stack_name ~= "technic:battery" then
+		return 0
+	end
+	return 1
+end
+
+-- something is about to be removed
+local function on_machine_downgrade(meta, stack, list)
+	if stack:get_name() == "default:chest" then
+		local inv = meta:get_inventory()
+		local upg1, upg2 = inv:get_stack("upgrade1", 1), inv:get_stack("upgrade2", 1)
+
+		-- only set 0 if theres not a nother chest in the other list too
+		if (not upg1 or not upg2 or upg1:get_name() ~= upg2:get_name()) then
+			meta:set_int("public", 0)
+		end
+	end
+	return 1
+end
+
+
+function technic.send_items(pos, x_velocity, z_velocity, output_name)
+	-- Send items on their way in the pipe system.
+	if output_name == nil then
+		output_name = "dst"
+	end
+
+	local meta = minetest.get_meta(pos)
+	local inv = meta:get_inventory()
+	local i = 0
+	for _, stack in ipairs(inv:get_list(output_name)) do
+		i = i + 1
+		if stack then
+			local item0 = stack:to_table()
+			if item0 then
+				item0["count"] = 1
+				technic.tube_inject_item(pos, pos, vector.new(x_velocity, 0, z_velocity), item0)
+				stack:take_item(1)
+				inv:set_stack(output_name, i, stack)
+				return
+			end
+		end
+	end
+end
+
+-- FIXME: This funtion is never used anywhere, what is it for?
+function technic.smelt_item(meta, result, speed)
+	local inv = meta:get_inventory()
+	meta:set_int("cook_time", meta:get_int("cook_time") + 1)
+	if meta:get_int("cook_time") < result.time / speed then
+		return
+	end
+	local afterfuel
+	result, afterfuel = minetest.get_craft_result({method = "cooking", width = 1, items = inv:get_list("src")})
+
+	if result and result.item then
+		meta:set_int("cook_time", 0)
+		-- check if there's room for output in "dst" list
+		if inv:room_for_item("dst", result.item) then
+			inv:set_stack("src", 1, afterfuel.items[1])
+			inv:add_item("dst", result.item)
+		end
+	end
+end
+
+function technic.handle_machine_pipeworks(pos, tube_upgrade, send_function)
+	if send_function == nil then
+		send_function = technic.send_items
+	end
+
+	local node = minetest.get_node(pos)
+	local meta = minetest.get_meta(pos)
+	local pos1 = vector.new(pos)
+	local x_velocity = 0
+	local z_velocity = 0
+
+	-- Output is on the left side of the furnace
+	if node.param2 == 3 then pos1.z = pos1.z - 1  z_velocity = -1 end
+	if node.param2 == 2 then pos1.x = pos1.x - 1  x_velocity = -1 end
+	if node.param2 == 1 then pos1.z = pos1.z + 1  z_velocity =  1 end
+	if node.param2 == 0 then pos1.x = pos1.x + 1  x_velocity =  1 end
+
+	local output_tube_connected = false
+	local node1 = minetest.get_node(pos1)
+	if minetest.get_item_group(node1.name, "tubedevice") > 0 then
+		output_tube_connected = true
+	end
+	local tube_time = meta:get_int("tube_time") + tube_upgrade
+	if tube_time >= 2 then
+		tube_time = 0
+		if output_tube_connected then
+			send_function(pos, x_velocity, z_velocity)
+		end
+	end
+	meta:set_int("tube_time", tube_time)
+end
+
+function technic.machine_can_dig(pos, player)
+	local meta = minetest.get_meta(pos)
+	local inv = meta:get_inventory()
+	if not inv:is_empty("src") or not inv:is_empty("dst") then
+		if player then
+			minetest.chat_send_player(player:get_player_name(),
+				S("Machine cannot be removed because it is not empty"))
+		end
+		return false
+	end
+
+	return true
+end
+
+function technic.machine_after_dig_node(pos, oldnode, oldmetadata, player)
+	if oldmetadata.inventory then
+		if oldmetadata.inventory.upgrade1 and oldmetadata.inventory.upgrade1[1] then
+			local stack = ItemStack(oldmetadata.inventory.upgrade1[1])
+			if not stack:is_empty() then
+				minetest.add_item(pos, stack)
+			end
+		end
+		if oldmetadata.inventory.upgrade2 and oldmetadata.inventory.upgrade2[1] then
+			local stack = ItemStack(oldmetadata.inventory.upgrade2[1])
+			if not stack:is_empty() then
+				minetest.add_item(pos, stack)
+			end
+		end
+	end
+
+	if minetest.registered_nodes[oldnode.name].tube then
+		pipeworks.after_dig(pos, oldnode, oldmetadata, player)
+	end
+end
+
+local function inv_change(pos, player, count, from_list, to_list, stack)
+	local playername = player:get_player_name()
+	local meta = minetest.get_meta(pos);
+	local public = (meta:get_int("public") == 1)
+	local to_upgrade = to_list == "upgrade1" or to_list == "upgrade2"
+	local from_upgrade = from_list == "upgrade1" or from_list == "upgrade2"
+
+	if (not public or to_upgrade or from_upgrade) and minetest.is_protected(pos, playername) then
+		minetest.chat_send_player(playername, S("Inventory move disallowed due to protection"))
+		return 0
+	end
+	if to_upgrade then
+		-- only place a single item into it, if it's empty
+		local empty = meta:get_inventory():is_empty(to_list)
+		if empty then
+			return on_machine_upgrade(meta, stack)
+		end
+		return 0
+	elseif from_upgrade then
+		-- only called on take (not move)
+		on_machine_downgrade(meta, stack, from_list)
+	end
+	return count
+end
+
+function technic.machine_inventory_put(pos, listname, index, stack, player)
+	return inv_change(pos, player, stack:get_count(), nil, listname, stack)
+end
+
+function technic.machine_inventory_take(pos, listname, index, stack, player)
+	return inv_change(pos, player, stack:get_count(), listname, nil, stack)
+end
+
+function technic.machine_inventory_move(pos, from_list, from_index,
+		to_list, to_index, count, player)
+	local stack = minetest.get_meta(pos):get_inventory():get_stack(from_list, from_index)
+	return inv_change(pos, player, count, from_list, to_list, stack)
+end

mods/technic_plus/technic/machines/register/compressor.lua

@@ -0,0 +1,9 @@
+
+local S = technic.getter
+
+function technic.register_compressor(data)
+	data.typename = "compressing"
+	data.machine_name = "compressor"
+	data.machine_desc = S("%s Compressor")
+	technic.register_base_machine(data)
+end

mods/technic_plus/technic/machines/register/compressor_recipes.lua

@@ -0,0 +1,54 @@
+
+local S = technic.getter
+
+technic.register_recipe_type("compressing", { description = S("Compressing") })
+
+function technic.register_compressor_recipe(data)
+	data.time = data.time or 4
+	technic.register_recipe("compressing", data)
+end
+
+local recipes = {
+	{"default:snowblock",          "default:ice"},
+	{"default:sand 2",             "default:sandstone"},
+	{"default:desert_sand 2",      "default:desert_sandstone"},
+	{"default:silver_sand 2",      "default:silver_sandstone"},
+	{"default:desert_sandstone",   "default:desert_stone"},
+	{"technic:mixed_metal_ingot",  "technic:composite_plate"},
+	{"default:copper_ingot 5",     "technic:copper_plate"},
+	{"technic:coal_dust 4",        "technic:graphite"},
+	{"technic:carbon_cloth",       "technic:carbon_plate"},
+	{"technic:uranium35_ingot 5",  "technic:uranium_fuel"},
+	{"technic:graphite 25",        "default:diamond"}
+}
+
+if minetest.get_modpath("ethereal") then
+	-- the density of charcoal is ~1/10 of coal, otherwise it's pure carbon
+	table.insert(recipes, {"ethereal:charcoal_lump 10", "default:coal_lump 1"})
+end
+
+
+-- defuse the default sandstone recipe, since we have the compressor to take over in a more realistic manner
+minetest.clear_craft({
+	recipe = {
+		{"default:sand", "default:sand"},
+		{"default:sand", "default:sand"},
+	},
+})
+minetest.clear_craft({
+	recipe = {
+		{"default:desert_sand", "default:desert_sand"},
+		{"default:desert_sand", "default:desert_sand"},
+	},
+})
+minetest.clear_craft({
+	recipe = {
+		{"default:silver_sand", "default:silver_sand"},
+		{"default:silver_sand", "default:silver_sand"},
+	},
+})
+
+for _, data in pairs(recipes) do
+	technic.register_compressor_recipe({input = {data[1]}, output = data[2]})
+end
+

mods/technic_plus/technic/machines/register/electric_furnace.lua

@@ -0,0 +1,9 @@
+
+local S = technic.getter
+
+function technic.register_electric_furnace(data)
+	data.typename = "cooking"
+	data.machine_name = "electric_furnace"
+	data.machine_desc = S("%s Furnace")
+	technic.register_base_machine(data)
+end

mods/technic_plus/technic/machines/register/extractor.lua

@@ -0,0 +1,9 @@
+
+local S = technic.getter
+
+function technic.register_extractor(data)
+	data.typename = "extracting"
+	data.machine_name = "extractor"
+	data.machine_desc = S("%s Extractor")
+	technic.register_base_machine(data)
+end

mods/technic_plus/technic/machines/register/extractor_recipes.lua

@@ -0,0 +1,117 @@
+
+local S = technic.getter
+
+technic.register_recipe_type("extracting", { description = S("Extracting") })
+
+function technic.register_extractor_recipe(data)
+	data.time = data.time or 4
+	technic.register_recipe("extracting", data)
+end
+
+if minetest.get_modpath("dye") then
+	-- check if we are using dye or unifieddyes
+	local unifieddyes = minetest.get_modpath("unifieddyes")
+
+	-- register recipes with the same crafting ratios as `dye` provides
+	local dye_recipes = {
+		{"technic:coal_dust",                 "dye:black 2"},
+		{"default:blueberries",               "dye:violet 2"},
+		{"default:grass_1",                   "dye:green 1"},
+		{"default:dry_shrub",                 "dye:brown 4"},
+		{"default:junglegrass",               "dye:green 2"},
+		{"default:cactus",                    "dye:green 4"},
+		{"flowers:chrysanthemum_green",       "dye:green 4"},
+		{"flowers:geranium",                  "dye:blue 4"},
+		{"flowers:dandelion_white",           "dye:white 4"},
+		{"flowers:dandelion_yellow",          "dye:yellow 4"},
+		{"flowers:tulip",                     "dye:orange 4"},
+		{"flowers:tulip_black",               "dye:black 8"},
+		{"flowers:rose",                      "dye:red 4"},
+		{"flowers:viola",                     "dye:violet 4"},
+		{"bushes:blackberry",                 unifieddyes and "unifieddyes:magenta_s50 4" or "dye:violet 4"},
+		{"bushes:blueberry",                  unifieddyes and "unifieddyes:magenta_s50 4" or "dye:magenta 4"},
+	}
+
+	if minetest.get_modpath("hunger") and minetest.get_modpath("ethereal") then
+		table.insert(dye_recipes, {"ethereal:willow_twig 12", "technic:aspirin_pill"})
+	end
+
+	if minetest.get_modpath("farming") then
+		-- Dyes ---
+		-- better recipes for farming's crafting methods (twice the output)
+		table.insert(dye_recipes, {"farming:chili_pepper", "dye:red 4"})
+		table.insert(dye_recipes, {"farming:beans", "dye:green 4"})
+		table.insert(dye_recipes, {"farming:grapes", "dye:violet 4"})
+		table.insert(dye_recipes, {"farming:cocoa_beans", "dye:brown 4"})
+		-- Some extra recipes:
+		-- Himalayan rhubarb root can give yellow dye IRL
+		table.insert(dye_recipes, {"farming:rhubarb", "dye:yellow 4"})
+		table.insert(dye_recipes, {"farming:onion", "dye:yellow 4"})
+		table.insert(dye_recipes, {"farming:blueberries", "dye:blue 4"})
+		table.insert(dye_recipes, {"farming:raspberries", "dye:red 4"})
+	end
+
+	if minetest.get_modpath("ethereal") then
+		table.insert(dye_recipes, {"ethereal:seaweed", "dye:dark_green 6"})
+		table.insert(dye_recipes, {"ethereal:coral2", "dye:cyan 6"})
+		table.insert(dye_recipes, {"ethereal:coral3", "dye:orange 6"})
+		table.insert(dye_recipes, {"ethereal:coral4", "dye:pink 6"})
+		table.insert(dye_recipes, {"ethereal:coral5", "dye:green 6"})
+		table.insert(dye_recipes, {"ethereal:fern", "dye:dark_green 4"})
+		table.insert(dye_recipes, {"ethereal:snowygrass", "dye:grey 4"})
+		table.insert(dye_recipes, {"ethereal:crystalgrass", "dye:blue 4"})
+	end
+
+	if minetest.get_modpath("bakedclay") then
+		table.insert(dye_recipes, {"bakedclay:delphinium", "dye:cyan 8"})
+		table.insert(dye_recipes, {"bakedclay:thistle", "dye:magenta 8"})
+		table.insert(dye_recipes, {"bakedclay:lazarus", "dye:pink 8"})
+		table.insert(dye_recipes, {"bakedclay:mannagrass", "dye:dark_green 8"})
+	end
+
+
+	if minetest.get_modpath("bonemeal") then
+		table.insert(dye_recipes, {"bonemeal:bone", "dye:white 8"})
+		table.insert(dye_recipes, {"bonemeal:bonemeal", "dye:white 4"})
+	end
+
+	for _, data in ipairs(dye_recipes) do
+		technic.register_extractor_recipe({input = {data[1]}, output = data[2]})
+	end
+
+	-- overwrite the existing crafting recipes
+	local dyes = {"white", "red", "yellow", "blue", "violet", "orange"}
+	for _, color in ipairs(dyes) do
+		minetest.clear_craft({
+			type = "shapeless",
+			recipe = {"group:flower,color_"..color},
+		})
+		minetest.register_craft({
+			type = "shapeless",
+			output = "dye:"..color.." 1",
+			recipe = {"group:flower,color_"..color},
+		})
+	end
+
+	minetest.clear_craft({
+		type = "shapeless",
+		recipe = {"group:coal"},
+	})
+	minetest.register_craft({
+		type = "shapeless",
+		output = "dye:black 1",
+		recipe = {"group:coal"},
+	})
+
+	if unifieddyes then
+		minetest.clear_craft({
+			type = "shapeless",
+			recipe = {"default:cactus"},
+		})
+		minetest.register_craft({
+			type = "shapeless",
+			output = "dye:green 1",
+			recipe = {"default:cactus"},
+		})
+	end
+end

mods/technic_plus/technic/machines/register/freezer.lua

@@ -0,0 +1,9 @@
+
+local S = technic.getter
+
+function technic.register_freezer(data)
+	data.typename = "freezing"
+	data.machine_name = "freezer"
+	data.machine_desc = S("%s Freezer")
+	technic.register_base_machine(data)
+end

mods/technic_plus/technic/machines/register/freezer_recipes.lua

@@ -0,0 +1,21 @@
+
+local S = technic.getter
+
+technic.register_recipe_type("freezing", { description = S("Freezing") })
+
+function technic.register_freezer_recipe(data)
+	data.time = data.time or 5
+	technic.register_recipe("freezing", data)
+end
+
+local recipes = {
+	{"bucket:bucket_water", { "default:ice", "bucket:bucket_empty" } },
+	{"bucket:bucket_river_water", { "default:ice", "bucket:bucket_empty" } },
+	{"default:dirt", "default:dirt_with_snow" },
+	{"bucket:bucket_lava", { "default:obsidian", "bucket:bucket_empty" } }
+}
+
+for _, data in pairs(recipes) do
+	technic.register_freezer_recipe({input = {data[1]}, output = data[2]})
+end
+

mods/technic_plus/technic/machines/register/generator.lua

@@ -0,0 +1,292 @@
+local S = technic.getter
+
+local fs_helpers = pipeworks.fs_helpers
+local tube_entry = "^pipeworks_tube_connection_metallic.png"
+
+local tube = {
+	insert_object = function(pos, node, stack, direction)
+		local meta = minetest.get_meta(pos)
+		local inv = meta:get_inventory()
+		return inv:add_item("src", stack)
+	end,
+	can_insert = function(pos, node, stack, direction)
+		local meta = minetest.get_meta(pos)
+		local inv = meta:get_inventory()
+		if meta:get_int("splitstacks") == 1 then
+			stack = stack:peek_item(1)
+		end
+		return inv:room_for_item("src", stack)
+	end,
+	connect_sides = {left=1, right=1, back=1, top=1, bottom=1},
+}
+
+function technic.register_generator(data)
+
+	local tier = data.tier
+	local ltier = string.lower(tier)
+
+	local groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+		technic_machine=1, ["technic_"..ltier]=1}
+	if data.tube then
+		groups.tubedevice = 1
+		groups.tubedevice_receiver = 1
+	end
+	local active_groups = {not_in_creative_inventory = 1}
+	for k, v in pairs(groups) do active_groups[k] = v end
+
+	local generator_formspec =
+		"size[8,9;]"..
+		"label[0,0;"..S("Fuel-Fired %s Generator"):format(tier).."]"..
+		"list[context;src;3,1;1,1;]"..
+		"image[4,1;1,1;default_furnace_fire_bg.png]"..
+		"list[current_player;main;0,5;8,4;]"..
+		"listring[]"
+
+	local desc = S("Fuel-Fired %s Generator"):format(tier)
+
+	local run = function(pos, node)
+		local meta = minetest.get_meta(pos)
+		local burn_time = meta:get_int("burn_time")
+		local burn_totaltime = meta:get_int("burn_totaltime")
+		-- If more to burn and the energy produced was used: produce some more
+		if burn_time > 0 then
+			meta:set_int(tier.."_EU_supply", data.supply)
+			burn_time = burn_time - 1
+			meta:set_int("burn_time", burn_time)
+		end
+		-- Burn another piece of fuel
+		if burn_time == 0 then
+			local inv = meta:get_inventory()
+			if not inv:is_empty("src") then
+				local fuellist = inv:get_list("src")
+				local fuel
+				local afterfuel
+				fuel, afterfuel = minetest.get_craft_result(
+						{method = "fuel", width = 1,
+						items = fuellist})
+				if not fuel or fuel.time == 0 then
+					meta:set_string("infotext", S("%s Out Of Fuel"):format(desc))
+					technic.swap_node(pos, "technic:"..ltier.."_generator")
+					meta:set_int(tier.."_EU_supply", 0)
+					return
+				end
+				meta:set_int("burn_time", fuel.time)
+				meta:set_int("burn_totaltime", fuel.time)
+				inv:set_stack("src", 1, afterfuel.items[1])
+				technic.swap_node(pos, "technic:"..ltier.."_generator_active")
+				meta:set_int(tier.."_EU_supply", data.supply)
+			else
+				technic.swap_node(pos, "technic:"..ltier.."_generator")
+				meta:set_int(tier.."_EU_supply", 0)
+			end
+		end
+		if burn_totaltime == 0 then burn_totaltime = 1 end
+		local percent = math.floor((burn_time / burn_totaltime) * 100)
+		meta:set_string("infotext", desc.." ("..percent.."%)")
+
+		local form_buttons = ""
+		if ltier ~= "lv" then
+			form_buttons = fs_helpers.cycling_button(
+				meta,
+				pipeworks.button_base,
+				"splitstacks",
+				{
+					pipeworks.button_off,
+					pipeworks.button_on
+				}
+			)..pipeworks.button_label
+		end
+		meta:set_string("formspec",
+			"size[8, 9]"..
+			"label[0, 0;"..minetest.formspec_escape(desc).."]"..
+			"list[context;src;3, 1;1, 1;]"..
+			"image[4, 1;1, 1;default_furnace_fire_bg.png^[lowpart:"..
+			(percent)..":default_furnace_fire_fg.png]"..
+			"list[current_player;main;0, 5;8, 4;]"..
+			"listring[]"..
+			form_buttons
+		)
+	end
+
+	local tentry = tube_entry
+	if ltier == "lv" then tentry = "" end
+
+	minetest.register_node("technic:"..ltier.."_generator", {
+		description = desc,
+		tiles = {
+				"technic_"..ltier.."_generator_top.png"..tentry,
+				"technic_machine_bottom.png"..tentry,
+				"technic_"..ltier.."_generator_side.png"..tentry,
+				"technic_"..ltier.."_generator_side.png"..tentry,
+				"technic_"..ltier.."_generator_side.png"..tentry,
+				"technic_"..ltier.."_generator_front.png"
+		},
+		paramtype2 = "facedir",
+		groups = groups,
+		connect_sides = {"bottom", "back", "left", "right"},
+		legacy_facedir_simple = true,
+		sounds = default.node_sound_wood_defaults(),
+		tube = data.tube and tube or nil,
+		on_construct = function(pos)
+			local meta = minetest.get_meta(pos)
+			local node = minetest.get_node(pos)
+			meta:set_string("infotext", desc)
+			meta:set_int(data.tier.."_EU_supply", 0)
+			meta:set_int("burn_time", 0)
+			meta:set_int("tube_time",  0)
+			local form_buttons = ""
+			if not string.find(node.name, ":lv_") then
+				form_buttons = fs_helpers.cycling_button(
+						meta,
+						pipeworks.button_base,
+						"splitstacks",
+						{
+							pipeworks.button_off,
+							pipeworks.button_on
+						}
+					)..pipeworks.button_label
+			end
+			meta:set_string("formspec", generator_formspec..form_buttons)
+			local inv = meta:get_inventory()
+			inv:set_size("src", 1)
+		end,
+		can_dig = technic.machine_can_dig,
+		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,
+		after_place_node = data.tube and pipeworks.after_place,
+		after_dig_node = technic.machine_after_dig_node,
+		on_receive_fields = function(pos, formname, fields, sender)
+			if not pipeworks.may_configure(pos, sender) then return end
+			fs_helpers.on_receive_fields(pos, fields)
+			local meta = minetest.get_meta(pos)
+			local node = minetest.get_node(pos)
+			local form_buttons = ""
+			if not string.find(node.name, ":lv_") then
+				form_buttons = fs_helpers.cycling_button(
+						meta,
+						pipeworks.button_base,
+						"splitstacks",
+						{
+							pipeworks.button_off,
+							pipeworks.button_on
+						}
+					)..pipeworks.button_label
+			end
+			meta:set_string("formspec", generator_formspec..form_buttons)
+		end,
+	})
+
+	minetest.register_node("technic:"..ltier.."_generator_active", {
+		description = desc,
+		tiles = {
+			"technic_"..ltier.."_generator_top.png"..tube_entry,
+			"technic_machine_bottom.png"..tube_entry,
+			"technic_"..ltier.."_generator_side.png"..tube_entry,
+			"technic_"..ltier.."_generator_side.png"..tube_entry,
+			"technic_"..ltier.."_generator_side.png"..tube_entry,
+			"technic_"..ltier.."_generator_front_active.png"
+		},
+		paramtype2 = "facedir",
+		groups = active_groups,
+		connect_sides = {"bottom"},
+		legacy_facedir_simple = true,
+		sounds = default.node_sound_wood_defaults(),
+		tube = data.tube and tube or nil,
+		drop = "technic:"..ltier.."_generator",
+		can_dig = technic.machine_can_dig,
+		after_dig_node = technic.machine_after_dig_node,
+		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)
+			-- Connected back?
+			if technic.get_timeout(tier, pos) > 0 then return false end
+
+			local meta = minetest.get_meta(pos)
+			local node = minetest.get_node(pos)
+
+			local burn_time = meta:get_int("burn_time") or 0
+
+			if burn_time <= 0 then
+				meta:set_int(tier.."_EU_supply", 0)
+				meta:set_int("burn_time", 0)
+				technic.swap_node(pos, "technic:"..ltier.."_generator")
+				return false
+			end
+
+			local burn_totaltime = meta:get_int("burn_totaltime") or 0
+			if burn_totaltime == 0 then burn_totaltime = 1 end
+			burn_time = burn_time - 1
+			meta:set_int("burn_time", burn_time)
+			local percent = math.floor(burn_time / burn_totaltime * 100)
+
+			local form_buttons = ""
+			if not string.find(node.name, ":lv_") then
+				form_buttons = fs_helpers.cycling_button(
+					meta,
+					pipeworks.button_base,
+					"splitstacks",
+					{
+						pipeworks.button_off,
+						pipeworks.button_on
+					}
+				)..pipeworks.button_label
+			end
+			meta:set_string("formspec",
+				"size[8, 9]"..
+				"label[0, 0;"..minetest.formspec_escape(desc).."]"..
+				"list[context;src;3, 1;1, 1;]"..
+				"image[4, 1;1, 1;default_furnace_fire_bg.png^[lowpart:"..
+				(percent)..":default_furnace_fire_fg.png]"..
+				"list[current_player;main;0, 5;8, 4;]"..
+				"listring[]"..
+				form_buttons
+			)
+			return true
+		end,
+		on_receive_fields = function(pos, formname, fields, sender)
+			if not pipeworks.may_configure(pos, sender) then return end
+			fs_helpers.on_receive_fields(pos, fields)
+			local meta = minetest.get_meta(pos)
+			local node = minetest.get_node(pos)
+			local form_buttons = ""
+			if not string.find(node.name, ":lv_") then
+				form_buttons = fs_helpers.cycling_button(
+						meta,
+						pipeworks.button_base,
+						"splitstacks",
+						{
+							pipeworks.button_off,
+							pipeworks.button_on
+						}
+					)..pipeworks.button_label
+			end
+
+			local burn_totaltime = meta:get_int("burn_totaltime") or 0
+			local burn_time = meta:get_int("burn_time")
+			local percent = math.floor(burn_time / burn_totaltime * 100)
+
+			meta:set_string("formspec",
+				"size[8, 9]"..
+				"label[0, 0;"..minetest.formspec_escape(desc).."]"..
+				"list[context;src;3, 1;1, 1;]"..
+				"image[4, 1;1, 1;default_furnace_fire_bg.png^[lowpart:"..
+				(percent)..":default_furnace_fire_fg.png]"..
+				"list[current_player;main;0, 5;8, 4;]"..
+				"listring[]"..
+				form_buttons
+			)
+		end,
+	})
+
+	technic.register_machine(tier, "technic:"..ltier.."_generator",        technic.producer)
+	technic.register_machine(tier, "technic:"..ltier.."_generator_active", technic.producer)
+end
+

mods/technic_plus/technic/machines/register/grinder.lua

@@ -0,0 +1,9 @@
+
+local S = technic.getter
+
+function technic.register_grinder(data)
+	data.typename = "grinding"
+	data.machine_name = "grinder"
+	data.machine_desc = S("%s Grinder")
+	technic.register_base_machine(data)
+end

mods/technic_plus/technic/machines/register/grinder_recipes.lua

@@ -0,0 +1,176 @@
+
+local S = technic.getter
+
+technic.register_recipe_type("grinding", { description = S("Grinding") })
+
+function technic.register_grinder_recipe(data)
+	data.time = data.time or 3
+	technic.register_recipe("grinding", data)
+end
+
+local recipes = {
+	-- Dusts
+	{"default:coal_lump",          "technic:coal_dust 2"},
+	{"default:copper_lump",        "technic:copper_dust 2"},
+	{"default:desert_stone",       "default:desert_sand"},
+	{"default:gold_lump",          "technic:gold_dust 2"},
+	{"default:iron_lump",          "technic:wrought_iron_dust 2"},
+	{"default:tin_lump",           "technic:tin_dust 2"},
+	{"technic:chromium_lump",      "technic:chromium_dust 2"},
+	{"technic:uranium_lump",       "technic:uranium_dust 2"},
+	{"technic:zinc_lump",          "technic:zinc_dust 2"},
+	{"technic:lead_lump",          "technic:lead_dust 2"},
+	{"technic:sulfur_lump",        "technic:sulfur_dust 2"},
+	{"default:stone",              "technic:stone_dust"},
+	{"default:sand",               "technic:stone_dust"},
+
+	-- Other
+	{"default:cobble",           "default:gravel"},
+	{"default:gravel",           "default:sand"},
+	{"default:sandstone",        "default:sand 2"}, -- reverse recipe can be found in the compressor
+	{"default:desert_sandstone", "default:desert_sand 2"}, -- reverse recipe can be found in the compressor
+	{"default:silver_sandstone", "default:silver_sand 2"}, -- reverse recipe can be found in the compressor
+
+	{"default:ice",              "default:snowblock"},
+}
+
+if minetest.get_modpath("ethereal") then
+	-- the density of charcoal is ~1/10 of coal, otherwise it's the same graphitic carbon
+	table.insert(recipes, {"ethereal:charcoal_lump 5", "technic:coal_dust 1"})
+end
+
+-- defuse the sandstone -> 4 sand recipe to avoid infinite sand bugs (also consult the inverse compressor recipe)
+minetest.clear_craft({
+	recipe = {
+		{"default:sandstone"}
+	},
+})
+minetest.clear_craft({
+	recipe = {
+		{"default:desert_sandstone"}
+	},
+})
+minetest.clear_craft({
+	recipe = {
+		{"default:silver_sandstone"}
+	},
+})
+
+if minetest.get_modpath("farming") then
+	table.insert(recipes, {"farming:seed_wheat",   "farming:flour 1"})
+end
+
+if minetest.get_modpath("moreores") then
+	table.insert(recipes, {"moreores:mithril_lump",   "technic:mithril_dust 2"})
+	table.insert(recipes, {"moreores:silver_lump",    "technic:silver_dust 2"})
+end
+
+if minetest.get_modpath("gloopores") or minetest.get_modpath("glooptest") then
+	table.insert(recipes, {"gloopores:alatro_lump",   "technic:alatro_dust 2"})
+	table.insert(recipes, {"gloopores:kalite_lump",   "technic:kalite_dust 2"})
+	table.insert(recipes, {"gloopores:arol_lump",     "technic:arol_dust 2"})
+	table.insert(recipes, {"gloopores:talinite_lump", "technic:talinite_dust 2"})
+	table.insert(recipes, {"gloopores:akalin_lump",   "technic:akalin_dust 2"})
+end
+
+if minetest.get_modpath("homedecor") then
+	table.insert(recipes, {"home_decor:brass_ingot", "technic:brass_dust 1"})
+end
+
+for _, data in pairs(recipes) do
+	technic.register_grinder_recipe({input = {data[1]}, output = data[2]})
+end
+
+-- dusts
+local function register_dust(name, ingot)
+	local lname = string.lower(name)
+	lname = string.gsub(lname, ' ', '_')
+	minetest.register_craftitem("technic:"..lname.."_dust", {
+		description = S("%s Dust"):format(S(name)),
+		inventory_image = "technic_"..lname.."_dust.png",
+	})
+	if ingot then
+		minetest.register_craft({
+			type = "cooking",
+			recipe = "technic:"..lname.."_dust",
+			output = ingot,
+		})
+		technic.register_grinder_recipe({ input = {ingot}, output = "technic:"..lname.."_dust 1" })
+	end
+end
+
+-- Sorted alphibeticaly
+register_dust("Brass",           "basic_materials:brass_ingot")
+register_dust("Bronze",          "default:bronze_ingot")
+register_dust("Carbon Steel",    "technic:carbon_steel_ingot")
+register_dust("Cast Iron",       "technic:cast_iron_ingot")
+register_dust("Chernobylite",    "technic:chernobylite_block")
+register_dust("Chromium",        "technic:chromium_ingot")
+register_dust("Coal",            nil)
+register_dust("Copper",          "default:copper_ingot")
+register_dust("Lead",            "technic:lead_ingot")
+register_dust("Gold",            "default:gold_ingot")
+register_dust("Mithril",         "moreores:mithril_ingot")
+register_dust("Silver",          "moreores:silver_ingot")
+register_dust("Stainless Steel", "technic:stainless_steel_ingot")
+register_dust("Stone",           "default:stone")
+register_dust("Sulfur",          nil)
+register_dust("Tin",             "default:tin_ingot")
+register_dust("Wrought Iron",    "technic:wrought_iron_ingot")
+register_dust("Zinc",            "technic:zinc_ingot")
+if minetest.get_modpath("gloopores") or minetest.get_modpath("glooptest") then
+	register_dust("Akalin",          "glooptest:akalin_ingot")
+	register_dust("Alatro",          "glooptest:alatro_ingot")
+	register_dust("Arol",            "glooptest:arol_ingot")
+	register_dust("Kalite",          nil)
+	register_dust("Talinite",        "glooptest:talinite_ingot")
+end
+
+for p = 0, 35 do
+	local nici = (p ~= 0 and p ~= 7 and p ~= 35) and 1 or nil
+	local psuffix = p == 7 and "" or p
+	local ingot = "technic:uranium"..psuffix.."_ingot"
+	local dust = "technic:uranium"..psuffix.."_dust"
+	minetest.register_craftitem(dust, {
+		description = S("%s Dust"):format(string.format(S("%.1f%%-Fissile Uranium"), p/10)),
+		inventory_image = "technic_uranium_dust.png",
+		on_place_on_ground = minetest.craftitem_place_item,
+		groups = {uranium_dust=1, not_in_creative_inventory=nici},
+	})
+	minetest.register_craft({
+		type = "cooking",
+		recipe = dust,
+		output = ingot,
+	})
+	technic.register_grinder_recipe({ input = {ingot}, output = dust })
+end
+
+local function uranium_dust(p)
+	return "technic:uranium"..(p == 7 and "" or p).."_dust"
+end
+for pa = 0, 34 do
+	for pb = pa+1, 35 do
+		local pc = (pa+pb)/2
+		if pc == math.floor(pc) then
+			minetest.register_craft({
+				type = "shapeless",
+				recipe = { uranium_dust(pa), uranium_dust(pb) },
+				output = uranium_dust(pc).." 2",
+			})
+		end
+	end
+end
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "technic:coal_dust",
+	burntime = 50,
+})
+
+if minetest.get_modpath("gloopores") or minetest.get_modpath("glooptest") then
+	minetest.register_craft({
+		type = "fuel",
+		recipe = "technic:kalite_dust",
+		burntime = 37.5,
+	})
+end

mods/technic_plus/technic/machines/register/grindings.lua

@@ -0,0 +1,73 @@
+local S = technic.getter
+local moretrees = minetest.get_modpath("moretrees")
+local dye = minetest.get_modpath("dye")
+
+-- sawdust, the finest wood/tree grinding
+local sawdust = "technic:sawdust"
+minetest.register_craftitem(sawdust, {
+	description = S("Sawdust"),
+	inventory_image = "technic_sawdust.png",
+})
+minetest.register_craft({ type = "fuel", recipe = sawdust, burntime = 6 })
+technic.register_compressor_recipe({ input = {sawdust .. " 4"}, output = "default:wood" })
+
+-- tree/wood grindings
+local function register_tree_grinding(name, tree, wood, extract, grinding_color)
+	local lname = string.lower(name)
+	lname = string.gsub(lname, ' ', '_')
+	local grindings_name = "technic:"..lname.."_grindings"
+	if not minetest.registered_craftitems[grindings_name] then
+		local inventory_image = "technic_"..lname.."_grindings.png"
+		if grinding_color then
+			inventory_image = inventory_image .. "^[colorize:" .. grinding_color
+		end
+		minetest.register_craftitem(grindings_name, {
+			description = S("%s Grinding"):format(S(name)),
+			inventory_image = inventory_image,
+		})
+		minetest.register_craft({
+			type = "fuel",
+			recipe = grindings_name,
+			burntime = 8,
+		})
+	end
+	technic.register_grinder_recipe({ input = { tree }, output = grindings_name .. " 4" })
+	technic.register_grinder_recipe({ input = { grindings_name }, output = sawdust .. " 4" })
+	if wood then
+		technic.register_grinder_recipe({ input = { wood }, output = grindings_name })
+	end
+	if extract then
+		technic.register_extractor_recipe({ input = { grindings_name .. " 4" }, output = extract})
+		technic.register_separating_recipe({
+			input = { grindings_name .. " 4" },
+			output = { sawdust .. " 4", extract }
+		})
+	end
+end
+
+local rubber_tree_planks = moretrees and "moretrees:rubber_tree_planks"
+local default_extract = dye and "dye:brown 2"
+
+-- https://en.wikipedia.org/wiki/Catechu ancient brown dye from the wood of acacia trees
+local acacia_extract = dye and "dye:brown 8"
+
+-- technic recipes don't support groups yet :/
+--register_tree_grinding("Common Tree", "group:tree", "group:wood", default_extract)
+
+register_tree_grinding("Acacia", "default:acacia_tree", "default:acacia_wood", acacia_extract)
+register_tree_grinding("Common Tree", "default:tree", "default:wood", default_extract)
+register_tree_grinding("Common Tree", "default:aspen_tree", "default:aspen_wood", default_extract)
+register_tree_grinding("Common Tree", "default:jungletree", "default:junglewood", default_extract)
+register_tree_grinding("Common Tree", "default:pine_tree", "default:pine_wood", default_extract)
+register_tree_grinding("Rubber Tree", "moretrees:rubber_tree_trunk", rubber_tree_planks, "technic:raw_latex")
+register_tree_grinding("Rubber Tree", "moretrees:rubber_tree_trunk_empty", nil, "technic:raw_latex")
+
+if moretrees then
+	local trees = {
+		"beech", "apple_tree", "oak", "sequoia", "birch", "palm",
+		"date_palm", "spruce", "cedar", "poplar", "willow", "fir"
+	}
+	for _,tree in pairs(trees) do
+		register_tree_grinding("Common Tree", "moretrees:"..tree.."_trunk", "moretrees:"..tree.."_planks", default_extract)
+	end
+end

mods/technic_plus/technic/machines/register/init.lua

@@ -0,0 +1,35 @@
+local path = technic.modpath.."/machines/register"
+
+dofile(path.."/common.lua")
+
+-- Wiring stuff
+dofile(path.."/cables.lua")
+dofile(path.."/battery_box.lua")
+
+-- Generators
+dofile(path.."/solar_array.lua")
+dofile(path.."/generator.lua")
+
+-- API for machines
+dofile(path.."/recipes.lua")
+dofile(path.."/machine_base.lua")
+
+-- Recipes
+dofile(path.."/alloy_recipes.lua")
+dofile(path.."/grinder_recipes.lua")
+dofile(path.."/extractor_recipes.lua")
+dofile(path.."/compressor_recipes.lua")
+dofile(path.."/centrifuge_recipes.lua")
+dofile(path.."/freezer_recipes.lua")
+
+-- Multi-Machine Recipes
+dofile(path.."/grindings.lua")
+
+-- Machines
+dofile(path.."/alloy_furnace.lua")
+dofile(path.."/electric_furnace.lua")
+dofile(path.."/grinder.lua")
+dofile(path.."/extractor.lua")
+dofile(path.."/compressor.lua")
+dofile(path.."/centrifuge.lua")
+dofile(path.."/freezer.lua")

mods/technic_plus/technic/machines/register/machine_base.lua

@@ -0,0 +1,282 @@
+
+local S = technic.getter
+
+local fs_helpers = pipeworks.fs_helpers
+local tube_entry = "^pipeworks_tube_connection_metallic.png"
+
+function technic.default_can_insert(pos, node, stack, direction)
+	local meta = minetest.get_meta(pos)
+	local inv = meta:get_inventory()
+	if meta:get_int("splitstacks") == 1 then
+		stack = stack:peek_item(1)
+	end
+	return inv:room_for_item("src", stack)
+end
+
+function technic.new_default_tube()
+	return {
+		insert_object = function(pos, node, stack, direction)
+			local meta = minetest.get_meta(pos)
+			local inv = meta:get_inventory()
+			return inv:add_item("src", stack)
+		end,
+		can_insert = technic.default_can_insert,
+		connect_sides = {left = 1, right = 1, back = 1, top = 1, bottom = 1},
+	}
+end
+
+local connect_default = {"bottom", "back", "left", "right"}
+
+local function round(v)
+	return math.floor(v + 0.5)
+end
+
+function technic.register_base_machine(data)
+	local typename = data.typename
+	local input_size = technic.recipes[typename].input_size
+	local machine_name = data.machine_name
+	local machine_desc = data.machine_desc
+	local tier = data.tier
+	local ltier = string.lower(tier)
+
+	data.modname = data.modname or minetest.get_current_modname()
+
+	local groups = {cracky = 2, technic_machine = 1, ["technic_"..ltier] = 1}
+	if data.tube then
+		groups.tubedevice = 1
+		groups.tubedevice_receiver = 1
+	end
+	local active_groups = {not_in_creative_inventory = 1}
+	for k, v in pairs(groups) do active_groups[k] = v end
+
+	local formspec =
+		"size[8,9;]"..
+		"list[context;src;"..(4-input_size)..",1;"..input_size..",1;]"..
+		"list[context;dst;5,1;2,2;]"..
+		"list[current_player;main;0,5;8,4;]"..
+		"label[0,0;"..machine_desc:format(tier).."]"..
+		"listring[context;dst]"..
+		"listring[current_player;main]"..
+		"listring[context;src]"..
+		"listring[current_player;main]"
+	if data.upgrade then
+		formspec = formspec..
+			"list[context;upgrade1;1,3;1,1;]"..
+			"list[context;upgrade2;2,3;1,1;]"..
+			"label[1,4;"..S("Upgrade Slots").."]"..
+			"listring[context;upgrade1]"..
+			"listring[current_player;main]"..
+			"listring[context;upgrade2]"..
+			"listring[current_player;main]"
+	end
+
+	local tube = technic.new_default_tube()
+	if data.can_insert then
+		tube.can_insert = data.can_insert
+	end
+	if data.insert_object then
+		tube.insert_object = data.insert_object
+	end
+
+	local run = function(pos, node)
+		local meta     = minetest.get_meta(pos)
+		local inv      = meta:get_inventory()
+		local eu_input = meta:get_int(tier.."_EU_input")
+
+		local machine_desc_tier = machine_desc:format(tier)
+		local machine_node      = data.modname..":"..ltier.."_"..machine_name
+		local machine_demand    = data.demand
+
+		-- Setup meta data if it does not exist.
+		if not eu_input then
+			meta:set_int(tier.."_EU_demand", machine_demand[1])
+			meta:set_int(tier.."_EU_input", 0)
+			return
+		end
+
+		local EU_upgrade, tube_upgrade = 0, 0
+		if data.upgrade then
+			EU_upgrade, tube_upgrade = technic.handle_machine_upgrades(meta)
+		end
+		if data.tube then
+			technic.handle_machine_pipeworks(pos, tube_upgrade)
+		end
+
+		local powered = eu_input >= machine_demand[EU_upgrade+1]
+		if powered then
+			meta:set_int("src_time", meta:get_int("src_time") + round(data.speed*10))
+		end
+		while true do
+			local result = inv:get_list("src") and technic.get_recipe(typename, inv:get_list("src"))
+			if not result then
+				technic.swap_node(pos, machine_node)
+				meta:set_string("infotext", S("%s Idle"):format(machine_desc_tier))
+				meta:set_int(tier.."_EU_demand", 0)
+				meta:set_int("src_time", 0)
+				return
+			end
+			meta:set_int(tier.."_EU_demand", machine_demand[EU_upgrade+1])
+			technic.swap_node(pos, machine_node.."_active")
+			meta:set_string("infotext", S("%s Active"):format(machine_desc_tier))
+			if meta:get_int("src_time") < round(result.time*10) then
+				if not powered then
+					technic.swap_node(pos, machine_node)
+					meta:set_string("infotext", S("%s Unpowered"):format(machine_desc_tier))
+				end
+				return
+			end
+			local output = result.output
+			if type(output) ~= "table" then output = { output } end
+			local output_stacks = {}
+			for _, o in ipairs(output) do
+				table.insert(output_stacks, ItemStack(o))
+			end
+			local room_for_output = true
+			inv:set_size("dst_tmp", inv:get_size("dst"))
+			inv:set_list("dst_tmp", inv:get_list("dst"))
+			for _, o in ipairs(output_stacks) do
+				if not inv:room_for_item("dst_tmp", o) then
+					room_for_output = false
+					break
+				end
+				inv:add_item("dst_tmp", o)
+			end
+			if not room_for_output then
+				technic.swap_node(pos, machine_node)
+				meta:set_string("infotext", S("%s Idle"):format(machine_desc_tier))
+				meta:set_int(tier.."_EU_demand", 0)
+				meta:set_int("src_time", round(result.time*10))
+				return
+			end
+			meta:set_int("src_time", meta:get_int("src_time") - round(result.time*10))
+			inv:set_list("src", result.new_input)
+			inv:set_list("dst", inv:get_list("dst_tmp"))
+		end
+	end
+
+	local tentry = tube_entry
+	if ltier == "lv" then
+		tentry = ""
+	end
+
+	minetest.register_node(data.modname..":"..ltier.."_"..machine_name, {
+		description = machine_desc:format(tier),
+		tiles = {
+			data.modname.."_"..ltier.."_"..machine_name.."_top.png"..tentry,
+			data.modname.."_"..ltier.."_"..machine_name.."_bottom.png"..tentry,
+			data.modname.."_"..ltier.."_"..machine_name.."_side.png"..tentry,
+			data.modname.."_"..ltier.."_"..machine_name.."_side.png"..tentry,
+			data.modname.."_"..ltier.."_"..machine_name.."_side.png"..tentry,
+			data.modname.."_"..ltier.."_"..machine_name.."_front.png"
+		},
+		paramtype2 = "facedir",
+		groups = groups,
+		tube = data.tube and tube or nil,
+		connect_sides = data.connect_sides or connect_default,
+		legacy_facedir_simple = true,
+		sounds = default.node_sound_wood_defaults(),
+		on_construct = function(pos)
+			local node = minetest.get_node(pos)
+			local meta = minetest.get_meta(pos)
+
+			local form_buttons = ""
+			if not string.find(node.name, ":lv_") then
+				form_buttons = fs_helpers.cycling_button(
+					meta,
+					pipeworks.button_base,
+					"splitstacks",
+					{
+						pipeworks.button_off,
+						pipeworks.button_on
+					}
+				)..pipeworks.button_label
+			end
+
+			meta:set_string("infotext", machine_desc:format(tier))
+			meta:set_int("tube_time",  0)
+			meta:set_string("formspec", formspec..form_buttons)
+			local inv = meta:get_inventory()
+			inv:set_size("src", input_size)
+			inv:set_size("dst", 4)
+			inv:set_size("upgrade1", 1)
+			inv:set_size("upgrade2", 1)
+		end,
+		can_dig = technic.machine_can_dig,
+		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,
+		after_place_node = data.tube and pipeworks.after_place,
+		after_dig_node = technic.machine_after_dig_node,
+		on_receive_fields = function(pos, formname, fields, sender)
+			if fields.quit then return end
+			if not pipeworks.may_configure(pos, sender) then return end
+			fs_helpers.on_receive_fields(pos, fields)
+			local node = minetest.get_node(pos)
+			local meta = minetest.get_meta(pos)
+			local form_buttons = ""
+			if not string.find(node.name, ":lv_") then
+				form_buttons = fs_helpers.cycling_button(
+					meta,
+					pipeworks.button_base,
+					"splitstacks",
+					{
+						pipeworks.button_off,
+						pipeworks.button_on
+					}
+				)..pipeworks.button_label
+			end
+			meta:set_string("formspec", formspec..form_buttons)
+		end,
+	})
+
+	minetest.register_node(data.modname..":"..ltier.."_"..machine_name.."_active",{
+		description = machine_desc:format(tier),
+		tiles = {
+			data.modname.."_"..ltier.."_"..machine_name.."_top.png"..tentry,
+			data.modname.."_"..ltier.."_"..machine_name.."_bottom.png"..tentry,
+			data.modname.."_"..ltier.."_"..machine_name.."_side.png"..tentry,
+			data.modname.."_"..ltier.."_"..machine_name.."_side.png"..tentry,
+			data.modname.."_"..ltier.."_"..machine_name.."_side.png"..tentry,
+			data.modname.."_"..ltier.."_"..machine_name.."_front_active.png"
+		},
+		paramtype2 = "facedir",
+		drop = data.modname..":"..ltier.."_"..machine_name,
+		groups = active_groups,
+		connect_sides = data.connect_sides or connect_default,
+		legacy_facedir_simple = true,
+		sounds = default.node_sound_wood_defaults(),
+		tube = data.tube and tube or nil,
+		can_dig = technic.machine_can_dig,
+		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_disabled_machine_name = data.modname..":"..ltier.."_"..machine_name,
+		on_receive_fields = function(pos, formname, fields, sender)
+			if fields.quit then return end
+			if not pipeworks.may_configure(pos, sender) then return end
+			fs_helpers.on_receive_fields(pos, fields)
+			local node = minetest.get_node(pos)
+			local meta = minetest.get_meta(pos)
+			local form_buttons = ""
+			if not string.find(node.name, ":lv_") then
+				form_buttons = fs_helpers.cycling_button(
+					meta,
+					pipeworks.button_base,
+					"splitstacks",
+					{
+						pipeworks.button_off,
+						pipeworks.button_on
+					}
+				)..pipeworks.button_label
+			end
+			meta:set_string("formspec", formspec..form_buttons)
+		end,
+	})
+
+	technic.register_machine(tier, data.modname..":"..ltier.."_"..machine_name,            technic.receiver)
+	technic.register_machine(tier, data.modname..":"..ltier.."_"..machine_name.."_active", technic.receiver)
+
+end -- End registration
+

mods/technic_plus/technic/machines/register/recipes.lua

@@ -0,0 +1,113 @@
+local have_ui = minetest.get_modpath("unified_inventory")
+
+technic.recipes = { cooking = { input_size = 1, output_size = 1 } }
+function technic.register_recipe_type(typename, origdata)
+	local data = {}
+	for k, v in pairs(origdata) do data[k] = v end
+	data.input_size = data.input_size or 1
+	data.output_size = data.output_size or 1
+	if have_ui and unified_inventory.register_craft_type and data.output_size == 1 then
+		unified_inventory.register_craft_type(typename, {
+			description = data.description,
+			width = data.input_size,
+			height = 1,
+		})
+	end
+	data.recipes = {}
+	technic.recipes[typename] = data
+end
+
+local function get_recipe_index(items)
+	if not items or type(items) ~= "table" then return false end
+	local l = {}
+	for i, stack in ipairs(items) do
+		l[i] = ItemStack(stack):get_name()
+	end
+	table.sort(l)
+	return table.concat(l, "/")
+end
+
+local function register_recipe(typename, data)
+	-- Handle aliases
+	for i, stack in ipairs(data.input) do
+		data.input[i] = ItemStack(stack):to_string()
+	end
+	if type(data.output) == "table" then
+		for i, v in ipairs(data.output) do
+			data.output[i] = ItemStack(data.output[i]):to_string()
+		end
+	else
+		data.output = ItemStack(data.output):to_string()
+	end
+
+	local recipe = {time = data.time, input = {}, output = data.output}
+	local index = get_recipe_index(data.input)
+	if not index then
+		print("[Technic] ignored registration of garbage recipe!")
+		return
+	end
+	for _, stack in ipairs(data.input) do
+		recipe.input[ItemStack(stack):get_name()] = ItemStack(stack):get_count()
+	end
+
+	technic.recipes[typename].recipes[index] = recipe
+	if have_ui and technic.recipes[typename].output_size == 1 then
+		unified_inventory.register_craft({
+			type = typename,
+			output = data.output,
+			items = data.input,
+			width = 0,
+		})
+	end
+end
+
+function technic.register_recipe(typename, data)
+	minetest.after(0.01, register_recipe, typename, data) -- Handle aliases
+end
+
+function technic.get_recipe(typename, items)
+	if typename == "cooking" then -- Already builtin in Minetest, so use that
+		local result, new_input = minetest.get_craft_result({
+			method = "cooking",
+			width = 1,
+			items = items})
+		-- Compatibility layer
+		if not result or result.time == 0 then
+			return nil
+		-- Workaround for recipes with replacements
+		elseif not new_input.items[1]:is_empty() and new_input.items[1]:get_name() ~= items[1]:get_name() then
+			items[1]:take_item(1)
+			return {time = result.time,
+			        new_input = {items[1]},
+			        output = {new_input.items[1], result.item}}
+		else
+			return {time = result.time,
+			        new_input = new_input.items,
+			        output = result.item}
+		end
+	end
+	local index = get_recipe_index(items)
+	if not index then
+		print("[Technic] ignored registration of garbage recipe!")
+		return
+	end
+	local recipe = technic.recipes[typename].recipes[index]
+	if recipe then
+		local new_input = {}
+		for i, stack in ipairs(items) do
+			if stack:get_count() < recipe.input[stack:get_name()] then
+				return nil
+			else
+				new_input[i] = ItemStack(stack)
+				new_input[i]:take_item(recipe.input[stack:get_name()])
+			end
+		end
+		return {time = recipe.time,
+		        new_input = new_input,
+		        output = recipe.output}
+	else
+		return nil
+	end
+end
+
+

mods/technic_plus/technic/machines/register/solar_array.lua

@@ -0,0 +1,66 @@
+
+local S = technic.getter
+
+function technic.register_solar_array(data)
+	local tier = data.tier
+	local ltier = string.lower(tier)
+
+	local run = function(pos, node)
+		-- The action here is to make the solar array produce power
+		-- Power is dependent on the light level and the height above ground
+		-- There are many ways to cheat by using other light sources like lamps.
+		-- As there is no way to determine if light is sunlight that is just a shame.
+		-- To take care of some of it solar panels do not work outside daylight hours or if
+		-- built below 0m
+		local pos1 = {}
+		local machine_name = S("Arrayed Solar %s Generator"):format(tier)
+		pos1.y = pos.y + 1
+		pos1.x = pos.x
+		pos1.z = pos.z
+
+		technic.get_or_load_node(pos1)
+		local light = minetest.get_node_light(pos1, nil)
+		local time_of_day = minetest.get_timeofday()
+		local meta = minetest.get_meta(pos)
+		light = light or 0
+
+		-- turn on array only during day time and if sufficient light
+		-- I know this is counter intuitive when cheating by using other light sources.
+		if light >= 12 and time_of_day >= 0.24 and time_of_day <= 0.76 and pos.y > 0 then
+			local charge_to_give = math.floor((light + pos.y) * data.power)
+			charge_to_give = math.max(charge_to_give, 0)
+			charge_to_give = math.min(charge_to_give, data.power * 50)
+			meta:set_string("infotext", S("@1 Active (@2)", machine_name,
+				technic.EU_string(charge_to_give)))
+			meta:set_int(tier.."_EU_supply", charge_to_give)
+		else
+			meta:set_string("infotext", S("%s Idle"):format(machine_name))
+			meta:set_int(tier.."_EU_supply", 0)
+		end
+	end
+
+	minetest.register_node("technic:solar_array_"..ltier, {
+		tiles = {"technic_"..ltier.."_solar_array_top.png",  "technic_"..ltier.."_solar_array_bottom.png",
+			 "technic_"..ltier.."_solar_array_side.png", "technic_"..ltier.."_solar_array_side.png",
+			 "technic_"..ltier.."_solar_array_side.png", "technic_"..ltier.."_solar_array_side.png"},
+		groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2, technic_machine=1, ["technic_"..ltier]=1},
+		connect_sides = {"bottom"},
+		sounds = default.node_sound_wood_defaults(),
+		description = S("Arrayed Solar %s Generator"):format(tier),
+		active = false,
+		drawtype = "nodebox",
+		paramtype = "light",
+		node_box = {
+			type = "fixed",
+			fixed = {-0.5, -0.5, -0.5, 0.5, 0, 0.5},
+		},
+		on_construct = function(pos)
+			local meta = minetest.get_meta(pos)
+			meta:set_int(tier.."_EU_supply", 0)
+		end,
+		technic_run = run,
+	})
+
+	technic.register_machine(tier, "technic:solar_array_"..ltier, technic.producer)
+end
+

mods/technic_plus/technic/machines/supply_converter.lua

@@ -0,0 +1,219 @@
+-- The supply converter is a generic device which can convert from
+-- LV to MV and back, and HV to MV and back.
+-- The machine is configured by the wiring below and above it.
+--
+-- It works like this:
+--   The top side is setup as the receiver side, the bottom as the producer side.
+--   Once the receiver side is powered it will deliver power to the other side.
+--   Unused power is wasted just like any other producer!
+
+local digilines_path = minetest.get_modpath("digilines")
+
+local S = technic.getter
+
+local cable_entry = "^technic_cable_connection_overlay.png"
+
+local function set_supply_converter_formspec(meta)
+	local formspec = "size[5,2.25]"..
+		"field[0.3,0.5;2,1;power;"..S("Input Power")..";"..meta:get_int("power").."]"
+	if digilines_path then
+		formspec = formspec..
+			"field[2.3,0.5;3,1;channel;Digiline Channel;"..meta:get_string("channel").."]"
+	end
+	-- 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("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("Supply Converter")).."]"
+	else
+		formspec = formspec.."button[0,1.75;5,1;disable;"..S("%s Enabled"):format(S("Supply Converter")).."]"
+	end
+	meta:set_string("formspec", formspec)
+end
+
+local supply_converter_receive_fields = function(pos, formname, fields, sender)
+	if not sender or minetest.is_protected(pos, sender:get_player_name()) then
+		return
+	end
+	local meta = minetest.get_meta(pos)
+	local power = nil
+	if fields.power then
+		power = tonumber(fields.power) or 0
+		power = math.max(power, 0)
+		power = math.min(power, 10000)
+		power = 100 * math.floor(power / 100)
+		if power == meta:get_int("power") then power = nil end
+	end
+	if power then meta:set_int("power", power) end
+	if fields.channel then meta:set_string("channel", fields.channel) 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_supply_converter_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 digiline_def = {
+	receptor = {
+		rules = technic.digilines.rules,
+		action = function() end
+	},
+	effector = {
+		rules = technic.digilines.rules,
+		action = function(pos, node, channel, msg)
+			if type(msg) ~= "string" then
+				return
+			end
+			local meta = minetest.get_meta(pos)
+			if channel ~= meta:get_string("channel") then
+				return
+			end
+			msg = msg:lower()
+			if msg == "get" then
+				digilines.receptor_send(pos, technic.digilines.rules, channel, {
+					enabled      = meta:get_int("enabled"),
+					power        = meta:get_int("power"),
+					mesecon_mode = meta:get_int("mesecon_mode")
+				})
+				return
+			elseif msg == "off" then
+				meta:set_int("enabled", 0)
+			elseif msg == "on" then
+				meta:set_int("enabled", 1)
+			elseif msg == "toggle" then
+				local onn = meta:get_int("enabled")
+				onn = 1-onn -- Mirror onn with pivot 0.5, so switch between 1 and 0.
+				meta:set_int("enabled", onn)
+			elseif msg:sub(1, 5) == "power" then
+				local power = tonumber(msg:sub(7))
+				if not power then
+					return
+				end
+				power = math.max(power, 0)
+				power = math.min(power, 10000)
+				power = 100 * math.floor(power / 100)
+				meta:set_int("power", power)
+			elseif msg:sub(1, 12) == "mesecon_mode" then
+				meta:set_int("mesecon_mode", tonumber(msg:sub(14)))
+			else
+				return
+			end
+			set_supply_converter_formspec(meta)
+		end
+	},
+}
+
+local run = function(pos, node, run_stage)
+	-- run only in producer stage.
+	if run_stage == technic.receiver then
+		return
+	end
+
+	local remain = 0.9
+	-- Machine information
+	local machine_name  = S("Supply Converter")
+	local meta          = minetest.get_meta(pos)
+	local enabled       = meta:get_int("enabled") == 1 and
+		(meta:get_int("mesecon_mode") == 0 or meta:get_int("mesecon_effect") ~= 0)
+
+	local demand = enabled and meta:get_int("power") or 0
+
+	local pos_up        = {x=pos.x, y=pos.y+1, z=pos.z}
+	local pos_down      = {x=pos.x, y=pos.y-1, z=pos.z}
+	local name_up       = minetest.get_node(pos_up).name
+	local name_down     = minetest.get_node(pos_down).name
+
+	local from = technic.get_cable_tier(name_up)
+	local to   = technic.get_cable_tier(name_down)
+
+	if from and to then
+		local input = meta:get_int(from.."_EU_input")
+		if (technic.get_timeout(from, pos) <= 0) or (technic.get_timeout(to, pos) <= 0) then
+			-- Supply converter timed out, either RE or PR network is not running anymore
+			input = 0
+		end
+		meta:set_int(from.."_EU_demand", demand)
+		meta:set_int(from.."_EU_supply", 0)
+		meta:set_int(to.."_EU_demand", 0)
+		meta:set_int(to.."_EU_supply", input * remain)
+		meta:set_string("infotext", S("@1 (@2 @3 -> @4 @5)", machine_name,
+			technic.EU_string(input), from,
+			technic.EU_string(input * remain), to))
+	else
+		meta:set_string("infotext", S("%s Has Bad Cabling"):format(machine_name))
+		if to then
+			meta:set_int(to.."_EU_supply", 0)
+		end
+		if from then
+			meta:set_int(from.."_EU_demand", 0)
+		end
+		return
+	end
+
+end
+
+minetest.register_node("technic:supply_converter", {
+	description = S("Supply Converter"),
+	tiles  = {
+		"technic_supply_converter_tb.png"..cable_entry,
+		"technic_supply_converter_tb.png"..cable_entry,
+		"technic_supply_converter_side.png",
+		"technic_supply_converter_side.png",
+		"technic_supply_converter_side.png",
+		"technic_supply_converter_side.png"
+		},
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2,
+		technic_machine=1, technic_all_tiers=1},
+	connect_sides = {"top", "bottom"},
+	sounds = default.node_sound_wood_defaults(),
+	on_receive_fields = supply_converter_receive_fields,
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("Supply Converter"))
+		if digilines_path then
+			meta:set_string("channel", "supply_converter"..minetest.pos_to_string(pos))
+		end
+		meta:set_int("power", 10000)
+		meta:set_int("enabled", 1)
+		meta:set_int("mesecon_mode", 0)
+		meta:set_int("mesecon_effect", 0)
+		set_supply_converter_formspec(meta)
+	end,
+	mesecons = mesecons,
+	digiline = digiline_def,
+	technic_run = run,
+	technic_on_disable = run,
+})
+
+minetest.register_craft({
+	output = 'technic:supply_converter 1',
+	recipe = {
+		{'basic_materials:gold_wire', 'technic:rubber',         'technic:doped_silicon_wafer'},
+		{'technic:mv_transformer', 'technic:machine_casing', 'technic:lv_transformer'},
+		{'technic:mv_cable',       'technic:rubber',         'technic:lv_cable'},
+	},
+	replacements = { {"basic_materials:gold_wire", "basic_materials:empty_spool"}, },
+})
+
+for tier, machines in pairs(technic.machines) do
+	technic.register_machine(tier, "technic:supply_converter", technic.producer_receiver)
+end
+

mods/technic_plus/technic/machines/switching_station.lua

@@ -0,0 +1,174 @@
+-- See also technic/doc/api.md
+
+local mesecons_path = minetest.get_modpath("mesecons")
+
+local S = technic.getter
+
+local cable_entry = "^technic_cable_connection_overlay.png"
+
+minetest.register_craft({
+	output = "technic:switching_station",
+	recipe = {
+		{"",                     "technic:lv_transformer", ""},
+		{"default:copper_ingot", "technic:machine_casing", "default:copper_ingot"},
+		{"technic:lv_cable",     "technic:lv_cable",       "technic:lv_cable"}
+	}
+})
+
+local function start_network(pos)
+	local tier = technic.sw_pos2tier(pos)
+	if not tier then
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("%s Has No Network"):format(S("Switching Station")))
+		return
+	end
+	local network_id = technic.sw_pos2network(pos) or technic.create_network(pos)
+	technic.activate_network(network_id)
+end
+
+local mesecon_def
+if mesecons_path then
+	mesecon_def = {effector = {
+		rules = mesecon.rules.default,
+	}}
+end
+
+minetest.register_node("technic:switching_station",{
+	description = S("Switching Station"),
+	tiles  = {
+		"technic_water_mill_top_active.png",
+		"technic_water_mill_top_active.png"..cable_entry,
+		"technic_water_mill_top_active.png",
+		"technic_water_mill_top_active.png",
+		"technic_water_mill_top_active.png",
+		"technic_water_mill_top_active.png"},
+	groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2, technic_all_tiers=1},
+	connect_sides = {"bottom"},
+	sounds = default.node_sound_wood_defaults(),
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("infotext", S("Switching Station"))
+		meta:set_string("channel", "switching_station"..minetest.pos_to_string(pos))
+		meta:set_string("formspec", "field[channel;Channel;${channel}]")
+		start_network(pos)
+	end,
+	on_destruct = function(pos)
+		-- Remove network when switching station is removed, if
+		-- there's another switching station network will be rebuilt.
+		local network_id = technic.sw_pos2network(pos)
+		if technic.networks[network_id] then
+			technic.remove_network(network_id)
+		end
+	end,
+	on_receive_fields = function(pos, formname, fields, sender)
+		if not fields.channel then
+			return
+		end
+		local plname = sender:get_player_name()
+		if minetest.is_protected(pos, plname) then
+			minetest.record_protection_violation(pos, plname)
+			return
+		end
+		local meta = minetest.get_meta(pos)
+		meta:set_string("channel", fields.channel)
+	end,
+	mesecons = mesecon_def,
+	digiline = {
+		receptor = {
+			rules = technic.digilines.rules,
+			action = function() end
+		},
+		effector = {
+			rules = technic.digilines.rules,
+			action = function(pos, node, channel, msg)
+				if msg ~= "GET" and msg ~= "get" then
+					return
+				end
+				local meta = minetest.get_meta(pos)
+				if channel ~= meta:get_string("channel") then
+					return
+				end
+				local network_id = technic.sw_pos2network(pos)
+				local network = network_id and technic.networks[network_id]
+				if network then
+					digilines.receptor_send(pos, technic.digilines.rules, channel, {
+						supply = network.supply,
+						demand = network.demand,
+						lag = network.lag
+					})
+				else
+					digilines.receptor_send(pos, technic.digilines.rules, channel, {
+						error = "No network",
+					})
+				end
+			end
+		},
+	},
+})
+
+-----------------------------------------------
+-- The action code for the switching station --
+-----------------------------------------------
+
+-- Timeout ABM
+-- Timeout for a node in case it was disconnected from the network
+-- A node must be touched by the station continuously in order to function
+minetest.register_abm({
+	label = "Machines: timeout check",
+	nodenames = {"group:technic_machine"},
+	interval   = 1,
+	chance     = 1,
+	action = function(pos, node, active_object_count, active_object_count_wider)
+		if not technic.machine_tiers[node.name] then
+			-- https://github.com/mt-mods/technic/issues/123
+			return
+		end
+		-- Check for machine timeouts for all tiers
+		local tiers = technic.machine_tiers[node.name]
+		local timed_out = true
+		for _, tier in ipairs(tiers) do
+			local timeout = technic.get_timeout(tier, pos)
+			if timeout > 0 then
+				technic.touch_node(tier, pos, timeout - 1)
+				timed_out = false
+			end
+		end
+		-- If all tiers for machine timed out take action
+		if timed_out then
+			technic.disable_machine(pos, node)
+		end
+	end,
+})
+
+--Re-enable network of switching station if necessary, similar to the timeout above
+minetest.register_abm({
+	label = "Machines: re-enable check",
+	nodenames = {"technic:switching_station"},
+	interval   = 1,
+	chance     = 1,
+	action = function(pos, node, active_object_count, active_object_count_wider)
+		local network_id = technic.sw_pos2network(pos)
+		-- Check if network is overloaded / conflicts with another network
+		if network_id then
+			local infotext
+			local meta = minetest.get_meta(pos)
+			if technic.is_overloaded(network_id) then
+				local remaining = technic.reset_overloaded(network_id)
+				if remaining > 0 then
+					infotext = S("%s Network Overloaded, Restart in %dms"):format(S("Switching Station"), remaining / 1000)
+				else
+					infotext = S("%s Restarting Network"):format(S("Switching Station"))
+				end
+				technic.network_infotext(network_id, infotext)
+			else
+				-- Network exists and is not overloaded, reactivate network
+				technic.activate_network(network_id)
+				infotext = technic.network_infotext(network_id)
+			end
+			meta:set_string("infotext", infotext)
+		else
+			-- Network does not exist yet, attempt to create new network here
+			start_network(pos)
+		end
+	end,
+})

mods/technic_plus/technic/machines/switching_station_globalstep.lua

@@ -0,0 +1,118 @@
+
+local has_monitoring_mod = minetest.get_modpath("monitoring")
+
+local active_switching_stations_metric, switching_stations_usage_metric
+
+if has_monitoring_mod then
+	active_switching_stations_metric = monitoring.gauge(
+		"technic_active_switching_stations",
+		"Number of active switching stations"
+	)
+
+	switching_stations_usage_metric = monitoring.counter(
+		"technic_switching_stations_usage",
+		"usage in microseconds cpu time"
+	)
+end
+
+-- the interval between technic_run calls
+local technic_run_interval = 1.0
+local set_default_timeout = technic.set_default_timeout
+
+-- iterate over all collected switching stations and execute the technic_run function
+local timer = 0
+minetest.register_globalstep(function(dtime)
+	timer = timer + dtime
+	if timer < technic_run_interval or not technic.powerctrl_state then
+		return
+	end
+	timer = 0
+
+	local max_lag = technic.get_max_lag()
+	-- slow down technic execution if the lag is higher than usual
+	if max_lag > 5.0 then
+		technic_run_interval = 5.0
+	elseif max_lag > 2.0 then
+		technic_run_interval = 4.0
+	elseif max_lag > 1.5 then
+		technic_run_interval = 3.0
+	elseif max_lag > 1.0 then
+		technic_run_interval = 1.5
+	else
+		-- normal run_interval
+		technic_run_interval = 1.0
+	end
+	set_default_timeout(math.ceil(technic_run_interval) + 1)
+
+	local now = minetest.get_us_time()
+
+	local active_switches = 0
+
+	for network_id, network in pairs(technic.active_networks) do
+		local pos = technic.network2sw_pos(network_id)
+
+		local node = technic.get_or_load_node(pos) or minetest.get_node(pos)
+
+		if node.name ~= "technic:switching_station" then
+			-- station vanished
+			technic.remove_network(network_id)
+
+		elseif network.timeout > now and not technic.is_overloaded(network_id) then
+			-- station active
+			active_switches = active_switches + 1
+
+			if network.skip > 0 then
+				network.skip = network.skip - 1
+			else
+				local start = minetest.get_us_time()
+				technic.network_run(network_id)
+				local switch_diff = network.average_lag(minetest.get_us_time() - start)
+
+				-- set lag in microseconds into the "lag" meta field
+				network.lag = switch_diff
+
+				-- overload detection
+				if switch_diff > 250000 then
+					network.skip = 30
+				elseif switch_diff > 150000 then
+					network.skip = 20
+				elseif switch_diff > 75000 then
+					network.skip = 10
+				elseif switch_diff > 50000 then
+					network.skip = 2
+				end
+
+				if network.skip > 0 then
+					-- calculate efficiency in percent and display it
+					local efficiency = math.floor(1/network.skip*100)
+					technic.network_infotext(network_id, "Polyfuse triggered, current efficiency: " ..
+						efficiency .. "% generated lag : " .. math.floor(switch_diff/1000) .. " ms")
+
+					-- remove laggy network from active index
+					-- it will be reactivated when a player is near it
+					technic.active_networks[network_id] = nil
+				end
+			end
+
+		else
+			-- station timed out
+			technic.active_networks[network_id] = nil
+
+		end
+	end
+
+	if has_monitoring_mod then
+		local time_usage = minetest.get_us_time() - now
+		active_switching_stations_metric.set(active_switches)
+		switching_stations_usage_metric.inc(time_usage)
+	end
+
+end)
+
+minetest.register_chatcommand("technic_flush_switch_cache", {
+	description = "removes all loaded networks from the cache",
+	privs = { server = true },
+	func = function()
+		technic.active_networks = {}
+	end
+})