fix naming

rename and fix sound jetpack
add sound jetpack
2025-04-25 10:12:45 +02:00 · 2025-04-25 00:14:45 +02:00 · 2025-04-24 21:12:15 +02:00 · 2025-04-24 20:52:55 +02:00 · 2025-04-24 13:46:45 +02:00 · 2025-04-23 14:22:18 +02:00
177 changed files with 8983 additions and 4320 deletions
--- a/README.md
+++ b/README.md
@@ -9,10 +9,17 @@ Currently IndustrialTest supports following games:
 ## Additional dependencies
 - Minetest Game
    - [3D Armor](https://content.minetest.net/packages/stu/3d_armor)
- MineClone2
+- VoxeLibre
    - none
 ## Optional dependencies
 - [Rubber Addon for MineClone](https://content.minetest.net/packages/biochemist/mcl_rubber)
 - [Pipeworks](https://content.minetest.net/packages/VanessaE/pipeworks)
 - [Logistica](https://content.minetest.net/packages/ZenonSeth/logistica)
 - [Mesecons](https://content.minetest.net/packages/Jeija/mesecons)
 ## Contributors
 - mrkubax10 <mrkubax10@onet.pl or mrkubax10 at irc.libera.chat> [programming, some graphics]
 - HandfulOfFrogs <<handfuloffrogs@gmail.com>> [some programming, graphics]
 - LuanHawk <Discord: LuanHawk#8733> [lead graphics]
 - Migdyn <<temp1@cubesoftware.xyz>> [graphics]
--- a/api.lua
+++ b/api.lua
@@ -1,789 +0,0 @@
 -- IndustrialTest
 -- Copyright (C) 2023 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
 industrialtest.api={}
 industrialtest.api.maceratorRecipes={}
 industrialtest.api.compressorRecipes={}
 industrialtest.api.extractorRecipes={}
 industrialtest.api.cableFormerRecipes={}
 industrialtest.api.geothermalGeneratorFuels={}
 industrialtest.api.waterMillFuels={}
 industrialtest.api.storageCells={}
 industrialtest.api.lvPowerFlow=600
 industrialtest.api.mvPowerFlow=2400
 industrialtest.api.hvPowerFlow=10200
 industrialtest.api.evPowerFlow=40800
 industrialtest.api.ivPowerFlow=163800
 industrialtest.internal.clamp=function(num,min,max)
 	return math.max(math.min(num,max),min)
 end
 -- \brief Adds power storage to metadata
 -- \param capacity How much EU item/node can store
 -- \param flow How much EU can flow in or out item/node per industrialtest.updateDelay
 -- \param ioConfig Input/Output configuration in following side order: -X, +X, -Y, +Y, -Z, +Z
 --                 a - bidirectional, i - input, o - output
 -- \returns nil
 industrialtest.api.addPowerStorage=function(meta,capacity,flow,ioConfig)
 	meta:set_int("industrialtest.powerCapacity",capacity)
 	meta:set_int("industrialtest.powerFlow",flow)
 	meta:set_int("industrialtest.powerAmount",0)
 	meta:set_string("industrialtest.ioConfig",ioConfig)
 end
 -- \brief Takes rotated node and side and outputs normalized side that can be used for ioConfig lookups
 -- \param pos Vector with node position
 -- \param side Node side. See industrialtest.api.addPowerStorage for possible values
 -- \returns Normalized side or in case of failure side argument back
 industrialtest.api.normalizeSide=function(pos,side)
 	local node=minetest.get_node(pos)
 	-- FIXME: improve code quality there
 	local translation={
 		[0]={
 			1,2,3,4,5,6
 		},
 		[1]={
 			5,6,3,4,2,1
 		},
 		[2]={
 			2,1,3,4,6,5
 		},
 		[3]={
 			6,5,3,4,1,2
 		}
 	}
 	if node.param2>3 then
 		return side
 	end
 	return translation[node.param2][side]
 end
 -- \brief Checks if metadata contains power storage
 -- \param meta MetaDataRef which should be checked
 -- \returns true if metadata contains power storage, false otherwise
 industrialtest.api.hasPowerStorage=function(meta)
 	local values={"industrialtest.powerCapacity","industrialtest.powerFlow","industrialtest.powerAmount","industrialtest.ioConfig"}
 	for _,value in ipairs(values) do
 		if not meta:contains(value) then
 			return false
 		end
 	end
 	return true
 end
 -- \brief Updates itemstack description to show current power storage information, additionally updates item wear bar.
 --        Function doesn't check if itemstack contains power storage so you should be sure that it does before calling this function
 -- \param itemstack ItemStack which should be updated
 -- \returns nil
 industrialtest.api.updateItemPowerText=function(itemstack)
 	local meta=itemstack:get_meta()
 	local def=minetest.registered_tools[itemstack:get_name()]
 	meta:set_string("description",S("@1\n@2 / @3 EU",def.description,meta:get_int("industrialtest.powerAmount"),meta:get_int("industrialtest.powerCapacity")))
 	itemstack:set_wear(65535-meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*65534)
 end
 -- \brief Adds power storage to item depending on it's definition
 -- \param itemstack ItemStack to which item storage should be added
 -- \returns true if power storage was successfully added, false otherwise
 industrialtest.api.preparePowerStorageItem=function(itemstack)
 	local meta=itemstack:get_meta()
 	local def=minetest.registered_tools[itemstack:get_name()]
 	if industrialtest.api.hasPowerStorage(meta) or not def or not def._industrialtest_powerStorage or not def._industrialtest_powerCapacity or not def._industrialtest_powerFlow then
 		return false
 	end
 	industrialtest.api.addPowerStorage(meta,def._industrialtest_powerCapacity,def._industrialtest_powerFlow,"n/a")
 	industrialtest.api.updateItemPowerText(itemstack)
 	return true
 end
 -- \brief Sets uses metadata value depending on item's definition
 -- \param itemstack ItemStack which should be altered
 -- \returns true if value was successfully added, false otherwise
 industrialtest.api.prepareToolItem=function(itemstack)
 	local def=minetest.registered_tools[itemstack:get_name()]
 	if not def or not def._industrialtest_tool or not def.tool_capabilities or not def.tool_capabilities.uses then
 		return false
 	end
 	local meta=itemstack:get_meta()
 	meta:set_int("industrialtest.uses",def.tool_capabilities.uses)
 	return true
 end
 -- \brief Adds wear to item after it's use
 -- \param itemstack ItemStack to which wear should be added
 -- \returns nil
 industrialtest.api.afterToolUse=function(itemstack)
 	local meta=itemstack:get_meta()
 	local def=minetest.registered_tools[itemstack:get_name()]
 	if not def or not def._industrialtest_tool or not def.tool_capabilities or not def.tool_capabilities.uses then
 		return
 	end
 	if not meta:contains("industrialtest.uses") then
 		industrialtest.prepareToolItem(itemstack)
 	end
 	local uses=meta:get_int("industrialtest.uses")-1
 	if uses==0 then
 		itemstack:set_count(0)
 		minetest.sound_play({name="default_tool_breaks"},{
 			gain=1,
 			fade=0,
 			pitch=1
 		},true)
 		return
 	end
 	meta:set_int("industrialtest.uses",uses)
 	itemstack:set_wear(65535-uses/def.tool_capabilities.uses*65535)
 end
 -- \brief Checks if power storage is fully charged
 -- \param meta MetaDataRef which should be checked
 -- \returns true if power storage is fully charged, false otherwise
 industrialtest.api.isFullyCharged=function(meta)
 	return meta:get_int("industrialtest.powerAmount")>=meta:get_int("industrialtest.powerCapacity")
 end
 -- \brief Adds power to power storage. Function doesn't check if meta contains power storage so you must be sure that it does.
 -- \param meta MetaDataRef to which power should be added
 -- \param amount Amount of power to add
 -- \returns How much of power was actually added
 industrialtest.api.addPower=function(meta,amount)
 	local powerAmount=meta:get_int("industrialtest.powerAmount")
 	local powerCapacity=meta:get_int("industrialtest.powerCapacity")
 	local prevPowerAmount=powerAmount
 	powerAmount=industrialtest.internal.clamp(powerAmount+amount,0,powerCapacity)
 	meta:set_int("industrialtest.powerAmount",powerAmount)
 	return powerAmount-prevPowerAmount
 end
 -- \brief Adds power to itemstack. Function checks if itemstack has power storage.
 -- \param itemstack ItemStack to which add power
 -- \param amount How much power to add
 -- \returns Amount of power added
 industrialtest.api.addPowerToItem=function(itemstack,amount)
 	local meta=itemstack:get_meta()
 	if not industrialtest.api.hasPowerStorage(meta) then
 		return 0
 	end
 	local added=industrialtest.api.addPower(meta,amount)
 	industrialtest.api.updateItemPowerText(itemstack)
 	return added
 end
 -- \brief Adds power to destination metadata while subtracting it from source metadata
 -- \Param srcMeta MetaDataRef from which take power
 -- \param destMeta MetaDataRef to which add power
 -- \returns How much of power was actually transferred
 industrialtest.api.transferPower=function(srcMeta,destMeta,amount)
 	local currentFlow=math.min(srcMeta:get_int("industrialtest.powerAmount"),amount)
 	if currentFlow==0 then
 		return 0
 	end
 	local actualFlow=industrialtest.api.addPower(destMeta,currentFlow)
 	srcMeta:set_int("industrialtest.powerAmount",srcMeta:get_int("industrialtest.powerAmount")-actualFlow)
 	return actualFlow
 end
 -- \brief Adds power to destination itemstack while subtracting it from source metadata
 -- \param srcMeta MetaDataRef from which take power
 -- \param itemstack ItemStack to which add power
 -- \returns How much of power was actually transferred
 industrialtest.api.transferPowerToItem=function(srcMeta,itemstack,amount)
 	local currentFlow=math.min(srcMeta:get_int("industrialtest.powerAmount"),amount)
 	if currentFlow==0 then
 		return 0
 	end
 	local actualFlow=industrialtest.api.addPowerToItem(itemstack,currentFlow)
 	srcMeta:set_int("industrialtest.powerAmount",srcMeta:get_int("industrialtest.powerAmount")-actualFlow)
 	return actualFlow
 end
 -- \brief Adds power to destination metadata while subtracting it from source itemstack
 -- \param srcItemstack ItemStack from which subtract power
 -- \param meta MetaDataRef to which add power
 -- \param amount How much power should be transferred
 -- \returns How much of power was actually transferred
 industrialtest.api.transferPowerFromItem=function(srcItemstack,meta,amount)
 	local srcMeta=srcItemstack:get_meta()
 	local currentFlow=math.min(srcMeta:get_int("industrialtest.powerAmount"),amount)
 	if currentFlow==0 then
 		return 0
 	end
 	local actualFlow=industrialtest.api.addPower(meta,currentFlow)
 	industrialtest.api.addPowerToItem(srcItemstack,-actualFlow)
 	return actualFlow
 end
 -- \brief Transfers power from source node to it's network, if sides is set then power will be only transfered to network connected to that sides
 -- \param pos Vector with position of source node
 -- \param (optional) sides table with Vectors
 -- \param (optional) flowOverride number
 -- \returns two values: true if any neighbouring node has room for more power, false otherwise
 --                      true if any power was transferred, false otherwise
 industrialtest.api.powerFlow=function(pos,sides,flowOverride)
 	local meta=minetest.get_meta(pos)
 	-- if machine doesn't have network map then it's not capable of transferring power
 	local network=industrialtest.api.getNetwork(meta)
 	if not network or #network==0 then
 		return false,false
 	end
 	local endpointCount=0
 	for _,endpoint in ipairs(network) do
 		local endpointMeta=minetest.get_meta(endpoint.position)
 		if not industrialtest.api.isFullyCharged(endpointMeta) and (not sides or sides[endpoint.sourceSide]) then
 			endpointCount=endpointCount+1
 		end
 	end
 	if endpointCount==0 then
 		return false,false
 	end
 	local powerDistribution=math.floor((flowOverride and flowOverride or meta:get_int("industrialtest.powerFlow"))/endpointCount)
 	local transferred=false
 	local roomAvailable=false
 	for _,endpoint in ipairs(network) do
 		if not sides or sides[endpoint.sourceSide] then
 			local endpointMeta=minetest.get_meta(endpoint.position)
 			if powerDistribution<=endpoint.flow then
 				local transferredPower=industrialtest.api.transferPower(meta,endpointMeta,powerDistribution)
 				if transferredPower>0 then
 					transferred=true
 				end
 				local def=minetest.registered_nodes[minetest.get_node(endpoint.position).name]
 				if def then
 					local updateFormspec=def._industrialtest_updateFormspec
 					if updateFormspec then
 						updateFormspec(endpoint.position)
 					end
 					local onPowerFlow=def._industrialtest_onPowerFlow
 					if onPowerFlow and transferredPower>0 then
 						onPowerFlow(endpoint.position,industrialtest.api.getOppositeSide(endpoint.side),transferredPower)
 					end
 				end
 				minetest.get_node_timer(endpoint.position):start(industrialtest.updateDelay)
 				if not industrialtest.api.isFullyCharged(endpointMeta) then
 					roomAvailable=true
 				end
 			else
 				minetest.remove_node(endpoint.position)
 				industrialtest.internal.explode(endpoint.position,2)
 			end
 		end
 	end
 	return roomAvailable,transferred
 end
 local function addNodeToNetwork(pos,networkMasterPos)
 	local meta=minetest.get_meta(pos)
 	local networks={}
 	if meta:contains("industrialtest.networks") then
 		networks=minetest.deserialize(meta:get_string("industrialtest.networks"))
 	end
 	for _,network in ipairs(networks) do
 		if network.x==networkMasterPos.x and network.y==networkMasterPos.y and network.z==networkMasterPos.z then
 			return
 		end
 	end
 	table.insert(networks,networkMasterPos)
 	meta:set_string("industrialtest.networks",minetest.serialize(networks))
 end
 local function clampFlow(pos,flow)
 	local def=minetest.registered_nodes[minetest.get_node(pos).name]
 	local newFlow
 	if def.groups and def.groups._industrialtest_cable then
 		newFlow=def._industrialtest_cableFlow
 	else
 		local meta=minetest.get_meta(pos)
 		newFlow=meta:get_int("industrialtest.powerFlow")
 	end
 	return math.min(flow,newFlow)
 end
 -- \brief Creates network map starting from node at pos, optionally omitting node at omit
 -- \param pos vector
 -- \param (optional) addCables bool
 -- \param (optional) omit Vector
 -- \returns table with network map
 industrialtest.api.createNetworkMap=function(pos,addCables,omit)
 	local workers={}
 	local map={}
 	local connections=industrialtest.api.getConnections(pos,"i")
 	if #connections==0 then
 		return map
 	end
 	local sides={
 		["-1,0,0"]=1,
 		["1,0,0"]=2,
 		["0,-1,0"]=3,
 		["0,1,0"]=4,
 		["0,0,-1"]=5,
 		["0,0,1"]=6
 	}
 	local serializedSourcePos=pos.x..","..pos.y..","..pos.z
 	local visitedNodes={[serializedSourcePos]=true}
 	for _,conn in ipairs(connections) do
 		if not omit or conn.x~=omit.x or conn.y~=omit.y or conn.z~=omit.z then
 			visitedNodes[conn.x..","..conn.y..","..conn.z]=true
 			addNodeToNetwork(conn,pos)
 			local sideVector=vector.subtract(conn,pos)
 			local serializedSideVector=sideVector.x..","..sideVector.y..","..sideVector.z
 			local def=minetest.registered_nodes[minetest.get_node(conn).name]
 			if def.groups._industrialtest_cable then
 				table.insert(workers,{
 					position=conn,
 					targetPosition=conn,
 					distance=1,
 					flow=def._industrialtest_cableFlow,
 					targetFlow=0,
 					sourceSide=industrialtest.api.normalizeSide(pos,sides[serializedSideVector])
 				})
 				if addCables then
 					table.insert(map,{
 						position=conn,
 						distance=0
 					})
 				end
 			else
 				local meta=minetest.get_meta(conn)
 				table.insert(map,{
 					position=conn,
 					distance=0,
 					flow=meta:get_int("industrialtest.powerFlow"),
 					side=sides[serializedSideVector],
 					sourceSide=industrialtest.api.normalizeSide(pos,sides[serializedSideVector])
 				})
 			end
 		end
 	end
 	while #workers>0 do
 		for i=1,#workers do
 			local worker=workers[i]
 			connections=industrialtest.api.getConnections(worker.position,"i")
 			if #connections==0 then
 				table.remove(workers,i)
 				break
 			else
 				local directionAssigned=false
 				local foundNewNode=false
 				for _,conn in ipairs(connections) do
 					if not omit or conn.x~=omit.x or conn.y~=omit.y or conn.z~=omit.z then
 						local serializedPos=conn.x..","..conn.y..","..conn.z
 						if not visitedNodes[serializedPos] then
 							local def=minetest.registered_nodes[minetest.get_node(conn).name]
 							visitedNodes[serializedPos]=true
 							foundNewNode=true
 							addNodeToNetwork(conn,pos)
 							if def.groups._industrialtest_cable then
 								if directionAssigned then
 									table.insert(workers,{
 										position=conn,
 										targetPosition=conn,
 										distance=worker.distance+1,
 										flow=clampFlow(conn,worker.flow),
 										targetFlow=0,
 										sourceSide=worker.sourceSide
 									})
 								else
 									worker.targetPosition=conn
 									worker.distance=worker.distance+1
 									worker.targetFlow=clampFlow(conn,worker.flow)
 									directionAssigned=true
 								end
 								if addCables then
 									table.insert(map,{
 										position=conn,
 										distance=worker.distance+1,
 									})
 								end
 							else
 								local sideVector=vector.subtract(conn,worker.position)
 								table.insert(map,{
 									position=conn,
 									distance=worker.distance,
 									flow=clampFlow(conn,worker.flow),
 									side=sides[sideVector.x..","..sideVector.y..","..sideVector.z],
 									sourceSide=worker.sourceSide
 								})
 								if #connections==1 then
 									foundNewNode=false
 									break
 								end
 							end
 						end
 					end
 				end
 				if not foundNewNode then
 					table.remove(workers,i)
 					break
 				end
 				worker.position=worker.targetPosition
 				worker.flow=worker.targetFlow
 			end
 		end
 	end
 	return map
 end
 industrialtest.api.removeNodeFromNetwork=function(pos,nodePos)
 	local meta=minetest.get_meta(pos)
 	local network=minetest.deserialize(meta:get_string("industrialtest.network"))
 	local removed=false
 	for key,node in ipairs(network) do
 		if node.position.x==nodePos.x and node.position.y==nodePos.y and node.position.z==nodePos.z then
 			table.remove(network,key)
 			removed=true
 			break
 		end
 	end
 	if removed then
 		meta:set_string("industrialtest.network",minetest.serialize(network))
 	end
 end
 -- \brief Creates network map and writes it to node metadata at pos, optionally omitting node at omit
 -- \param pos Vector
 -- \param (optional) omit Vector
 -- \returns nil
 industrialtest.api.createNetworkMapForNode=function(pos,omit)
 	local meta=minetest.get_meta(pos)
 	local network=industrialtest.api.createNetworkMap(pos,false,omit)
 	meta:set_string("industrialtest.network",minetest.serialize(network))
 end
 -- \brief Returns true if meta contains network map, false otherwise
 -- \param meta MetaDataRef
 -- \returns bool
 industrialtest.api.isNetworkMaster=function(meta)
 	return meta:contains("industrialtest.network")
 end
 -- \brief Returns network table if node containing meta belongs to any networks, false otherwise
 -- \param meta MetaDataRef
 -- \returns bool or table
 industrialtest.api.isAttachedToNetwork=function(meta)
 	if not meta:contains("industrialtest.networks") then
 		return false
 	end
 	local networks=minetest.deserialize(meta:get_string("industrialtest.networks"))
 	if #networks==0 then
 		return false
 	end
 	return networks
 end
 -- \brief Returns network master network from it's meta, if meta doesn't contain network map then function returns false
 -- \param meta MetaDataRef
 -- \returns table or bool
 industrialtest.api.getNetwork=function(meta)
 	if not meta:contains("industrialtest.network") then
 		return false
 	end
 	return minetest.deserialize(meta:get_string("industrialtest.network"))
 end
 -- \brief Returns opposite side of provided one
 -- \param side Side number. See industrialtest.api.addPowerStorage for order
 -- \returns Opposite side
 industrialtest.api.getOppositeSide=function(side)
 	return (side%2==0 and side-1 or side+1)
 end
 -- \brief Returns connections of node with power storage. If direction is "i" only input connections will be returned, if direction is "o" only output connections
 --        will be returned, if it's not provided all connections will be returned.
 -- \param pos Vector
 -- \param (optional) direction string
 -- \returns table
 industrialtest.api.getConnections=function(pos,direction)
 	local result={}
 	local neighbourPositions={
 		vector.offset(pos,-1,0,0),
 		vector.offset(pos,1,0,0),
 		vector.offset(pos,0,-1,0),
 		vector.offset(pos,0,1,0),
 		vector.offset(pos,0,0,-1),
 		vector.offset(pos,0,0,1)
 	}
 	local sourceMeta=minetest.get_meta(pos)
 	local sourceDef=minetest.registered_nodes[minetest.get_node(pos).name]
 	local directionOutput=(not direction or direction=="o")
 	local directionInput=(not direction or direction=="i")
 	for key,conn in ipairs(neighbourPositions) do
 		local meta=minetest.get_meta(conn)
 		local def=minetest.registered_nodes[minetest.get_node(conn).name]
 		local normalizedKey=industrialtest.api.normalizeSide(pos,key)
 		local powerOutput=(sourceDef.groups._industrialtest_cable or industrialtest.api.isPowerOutput(sourceMeta,normalizedKey))
 		local powerInput=(sourceDef.groups._industrialtest_cable or industrialtest.api.isPowerInput(sourceMeta,normalizedKey))
 		if def.groups._industrialtest_cable or industrialtest.api.hasPowerStorage(meta) then
 			local side=industrialtest.api.getOppositeSide(normalizedKey)
 			if (powerOutput and directionInput and (def.groups._industrialtest_cable or industrialtest.api.isPowerInput(meta,side))) or ((def.groups._industrialtest_cable or industrialtest.api.isPowerOutput(meta,side)) and powerInput and directionOutput) then
 				table.insert(result,conn)
 			end
 		end
 	end
 	return result
 end
 -- \brief Changes node's power IO config. Function doesn't check if meta actually contains power storage.
 -- \param meta MetaDataRef of node which power IO config should be changed
 -- \param side Side number. See industrialtest.api.addPowerStorage to check order.
 -- \param mode Side mode. See industrialtest.api.addPowerStorage for possible values.
 -- \returns nil
 industrialtest.api.changeIoConfig=function(meta,side,mode)
 	local ioConfig=meta:get_string("industrialtest.ioConfig")
 	ioConfig=string.sub(ioConfig,1,side-1)..mode..string.sub(ioConfig,side+1)
 	meta:set_string("industrialtest.ioConfig",ioConfig)
 end
 -- \brief Checks if provided side is power input
 -- \param meta MetaDataRef of node
 -- \param side Side number. See industrialtest.api.addPowerStorage to check order.
 -- \returns true if provided side is power input, false otherwise
 industrialtest.api.isPowerInput=function(meta,side)
 	local ioConfig=meta:get_string("industrialtest.ioConfig")
 	local mode=string.sub(ioConfig,side,side)
 	return (mode=="i" or mode=="a")
 end
 -- \brief Checks if provided side is power output
 -- \param meta MetaDataRef of node
 -- \param side Side number. See industrialtest.api.addPowerStorage to check order.
 -- \returns true if provided side is power output, false otherwise
 industrialtest.api.isPowerOutput=function(meta,side)
 	local ioConfig=meta:get_string("industrialtest.ioConfig")
 	local mode=string.sub(ioConfig,side,side)
 	return (mode=="o" or mode=="a")
 end
 -- \brief Registers dust of certain resource
 -- \param name Technical name of resource
 -- \param displayName Display name of resource
 -- \param resources List of tables with following keys: <output>, <recipe>, [count(1)]
 --                                                      <> - required, [] - optional, () - default value
 -- \param color HTML color of dust
 -- \param registerMaceratorRecipe If true macerator recipe for dust will be registered
 -- \returns nil
 industrialtest.api.registerResourceDust=function(name,displayName,resources,color,registerMaceratorRecipe)
 	minetest.register_craftitem("industrialtest:"..name.."_dust",{
 		description=S(displayName.." Dust"),
 		inventory_image="industrialtest_dust.png",
 		color=color
 	})
 	if registerMaceratorRecipe then
 		for _,value in ipairs(resources) do
 			industrialtest.api.registerMaceratorRecipe({
 				output="industrialtest:"..name.."_dust "..(value.count or 1),
 				recipe=value.resource
 			})
 		end
 	end
 end
 -- \brief Registers plate of certain resource
 -- \param name Technical name of resource
 -- \param displayName Display name of resource
 -- \param resources List of tables with following keys: <output>, <recipe>, [count(1)]
 --                                                      <> - required, [] - optional, () - default value
 -- \param color HTML color of plate
 -- \param registerCompressorRecipe If true compressor recipe for plate will be registered
 -- \returns nil
 industrialtest.api.registerPlate=function(name,displayName,resources,color,registerCompressorRecipe)
 	minetest.register_craftitem("industrialtest:"..name,{
 		description=displayName,
 		inventory_image="industrialtest_plate.png",
 		color=color
 	})
 	if registerCompressorRecipe then
 		for _,value in ipairs(resources) do
 			industrialtest.api.registerCompressorRecipe({
 				output="industrialtest:"..name.." "..(value.count or 1),
 				recipe=value.resource
 			})
 		end
 	end
 end
 -- \brief Registers cell with certain fluid
 -- \param name Technical name of cell
 -- \param displayName Display name of cell
 -- \param node Node which can be picked up with this cell
 -- \returns nil
 industrialtest.api.registerStorageCell=function(name,displayName,node,modname)
 	if not modname then
 		modname="industrialtest"
 	end
 	minetest.register_craftitem("industrialtest:"..name.."_cell",{
 		description=S(displayName.." Cell"),
 		inventory_image=modname.."_"..name.."_cell.png",
 		on_place=function(itemstack,user,pointed)
 			if pointed.type~="node" or not user or not user:is_player() then
 				return nil
 			end
 			local node=minetest.get_node_or_nil(pointed.above)
 			local storage=industrialtest.api.getStorageCell("industrialtest:"..name.."_cell")
 			if storage.node then
 				if node.name~="air" and node.name~=storage.node then
 					return nil
 				end
 				minetest.set_node(pointed.above,{name=storage.node})
 				if itemstack:get_count()==1 then
 					itemstack:set_name("industrialtest:empty_cell")
 				else
 					local inv=user:get_inventory()
 					inv:add_item("main",ItemStack("industrialtest:empty_cell"))
 					itemstack:take_item()
 				end
 				return itemstack
 			end
 			return nil
 		end
 	})
 	industrialtest.api.storageCells["industrialtest:"..name.."_cell"]={
 		name="industrialtest:"..name.."_cell",
 		node=node
 	}
 end
 -- \brief Returns registred storage cell by name
 -- \param name Storage cell name
 -- \returns Table with following keys: name, node or nil in case of failure
 industrialtest.api.getStorageCell=function(name)
 	return industrialtest.api.storageCells[name]
 end
 -- \brief Returns registered storage cells by node
 -- \param node Node ID
 -- \returns Table with following keys: name, node or nil in case of failure
 industrialtest.api.getStorageCellByNode=function(node)
 	for _,value in pairs(industrialtest.api.storageCells) do
 		if value.node==node then
 			return value
 		end
 	end
 	return nil
 end
 -- \brief Registers macerator recipe
 -- \param config Table with keys: <output>, <recipe>, [time(2)]
 -- \returns nil
 industrialtest.api.registerMaceratorRecipe=function(config)
 	local definition={
 		output=config.output or "",
 		recipe=config.recipe or "",
 		time=config.time or 2
 	}
 	industrialtest.api.maceratorRecipes[definition.recipe]=definition
 end
 -- \brief Returns macerator recipe result
 -- \param recipe String ID of resulting conten
 -- \returns Table with following keys: output, recipe, time
 industrialtest.api.getMaceratorRecipeResult=function(recipe)
 	return industrialtest.api.maceratorRecipes[recipe]
 end
 -- \brief Registers compressor recipe
 -- \param config Table with following keys: <output>, <recipe>, [time(2)], [count(1)]
 -- \returns nil
 industrialtest.api.registerCompressorRecipe=function(config)
 	local definition={
 		output=config.output or "",
 		recipe=config.recipe or "",
 		time=config.time or 2,
 		count=config.count or 1
 	}
 	industrialtest.api.compressorRecipes[definition.recipe]=definition
 end
 -- \brief Returns macerator recipe result
 -- \param recipe String ID of resulting conten
 -- \returns Table with following keys: output, recipe, time
 industrialtest.api.getCompressorRecipeResult=function(recipe)
 	return industrialtest.api.compressorRecipes[recipe]
 end
 industrialtest.api.registerExtractorRecipe=function(config)
 	local definition={
 		output=config.output or "",
 		recipe=config.recipe or "",
 		time=config.time or 2
 	}
 	industrialtest.api.extractorRecipes[definition.recipe]=definition
 end
 industrialtest.api.getExtractorRecipeResult=function(recipe)
 	return industrialtest.api.extractorRecipes[recipe]
 end
 industrialtest.api.registerCableFormerRecipe=function(config)
 	local definition={
 		output=config.output or "",
 		recipe=config.recipe or "",
 		time=config.time or 2
 	}
 	industrialtest.api.cableFormerRecipes[definition.recipe]=definition
 end
 industrialtest.api.getCableFormerRecipeResult=function(recipe)
 	return industrialtest.api.cableFormerRecipes[recipe]
 end
 -- \brief Registers fuel that can be used in geothermal generator
 -- \param fuel Table with following keys: <name>, <calorificValue>, <storageItems>
 --        which is a table containing items which are tables with following keys: <name>, <leftover>
 -- \returns nil
 industrialtest.api.registerGeothermalGeneratorFuel=function(config)
 	local definition={
 		name=config.name or "",
 		calorificValue=config.calorificValue or 0,
 		texture=config.texture or "industrialtest_gui_fluid_bg.png",
 		storageItems=config.storageItems or {}
 	}
 	industrialtest.api.geothermalGeneratorFuels[definition.name]=definition
 end
 -- \brief Returns generator fuel information
 -- \param name Name of fuel
 -- \returns Table with following keys: name, calorificValue, storageItems
 industrialtest.api.getGeothermalGeneratorFuel=function(name)
 	return industrialtest.api.geothermalGeneratorFuels[name]
 end
 -- \brief Returns generator fuel information by item name
 -- \param name ID of item
 -- \returns Table with following keys: name, calorificValue, storageItems or nil in case of failure
 industrialtest.api.getGeothermalGeneratorFuelByItem=function(name)
 	for _,value in pairs(industrialtest.api.geothermalGeneratorFuels) do
 		for _,item in ipairs(value.storageItems) do
 			if item.name==name then
 				return value
 			end
 		end
 	end
 	return nil
 end
 -- \brief Registers fuel that can be used in water mill
 -- \param fuel Table with following keys: <name>, <calorificValue>, <storageItems>
 --        which is a table containing items which are tables with following keys: <name>, <leftover>
 -- \returns nil
 industrialtest.api.registerWaterMillFuel=function(config)
 	local definition={
 		name=config.name or "",
 		calorificValue=config.calorificValue or 0,
 		texture=config.texture or "industrialtest_gui_fluid_bg.png",
 		storageItems=config.storageItems or {}
 	}
 	industrialtest.api.waterMillFuels[definition.name]=definition
 end
 -- \brief Returns water mill fuel information
 -- \param name Name of fuel
 -- \returns Table with following keys: name, calorificValue, storageItems
 industrialtest.api.getWaterMillFuel=function(name)
 	return industrialtest.api.waterMillFuels[name]
 end
 -- \brief Returns water mill fuel information by item name
 -- \param name ID of item
 -- \returns Table with following keys: name, calorificValue, storageItems or nil in case of failure
 industrialtest.api.getWaterMillFuelByItem=function(name)
 	for _,value in pairs(industrialtest.api.waterMillFuels) do
 		for _,item in ipairs(value.storageItems) do
 			if item.name==name then
 				return value
 			end
 		end
 	end
 	return nil
 end
 -- \brief Returns machine speed in items per operation
 -- \param meta MetaDataRef
 -- \returns number
 industrialtest.api.getMachineSpeed=function(meta)
 	return meta:contains("industrialtest.speed") and meta:get_int("industrialtest.speed") or 1
 end
--- a/api/common.lua
+++ b/api/common.lua
@@ -0,0 +1,50 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 industrialtest.api={
 	maceratorRecipes={},
 	compressorRecipes={},
 	extractorRecipes={},
 	cableFormerRecipes={},
 	geothermalGeneratorFuels={},
 	waterMillFuels={},
 	rotaryMaceratorModifiers={},
 	storageCells={},
 	tags={}
 }
 industrialtest.api.lvPowerFlow=600
 industrialtest.api.mvPowerFlow=2400
 industrialtest.api.hvPowerFlow=10200
 industrialtest.api.evPowerFlow=40800
 industrialtest.api.ivPowerFlow=163800
 function industrialtest.internal.clamp(num,min,max)
 	return math.max(math.min(num,max),min)
 end
 function industrialtest.internal.unpackTableInto(first,second)
 	for k,v in pairs(second) do
 		first[k]=v
 	end
 end
 -- \brief Returns machine speed in items per operation
 -- \param meta MetaDataRef
 -- \returns number
 function industrialtest.api.getMachineSpeed(meta)
 	return meta:contains("industrialtest.speed") and meta:get_int("industrialtest.speed") or 1
 end
--- a/api/fluid.lua
+++ b/api/fluid.lua
@@ -0,0 +1,121 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
 -- \brief Prepares itemstack containing fluid storage
 -- \param itemstack ItemStack
 -- \returns bool
 function industrialtest.api.prepareFluidStorageItem(itemstack)
 	local meta=itemstack:get_meta()
 	local def=itemstack:get_definition()
 	if industrialtest.api.itemHasFluidStorage(itemstack) or not def.groups or not def.groups._industrialtest_fluidStorage or not def._industrialtest_fluidCapacity then
 		return false
 	end
 	meta:set_int("industrialtest.fluidAmount",0)
 	meta:set_int("industrialtest.fluidCapacity",def._industrialtest_fluidCapacity)
 	industrialtest.api.updateItemFluidText(itemstack)
 	return true
 end
 -- \brief Check if itemstack contains fluid storage
 -- \param itemstack ItemStack
 -- \returns bool
 function industrialtest.api.itemHasFluidStorage(itemstack)
 	local values={"industrialtest.fluidAmount","industrialtest.fluidCapacity"}
 	local meta=itemstack:get_meta()
 	for _,value in ipairs(values) do
 		if not meta:contains(value) then
 			return false
 		end
 	end
 	return true
 end
 -- \brief Check if fluid storage in meta is full
 -- \param meta MetaDataRef
 -- \returns bool
 function industrialtest.api.isFluidStorageFull(meta)
 	return meta:get_int("industrialtest.fluidAmount")>=meta:get_int("industrialtest.fluidCapacity")
 end
 -- \brief Check if item fluid storage is full
 -- \param itemstack ItemStack
 -- \returns bool
 function industrialtest.api.isItemFluidStorageFull(itemstack)
 	local meta=itemstack:get_meta()
 	return industrialtest.api.isFluidStorageFull(meta)
 end
 -- \brief Check if fluid storage in meta is empty
 -- \param meta MetaDataRef
 -- \returns bool
 function industrialtest.api.isFluidStorageEmpty(meta)
 	return meta:get_int("industrialtest.fluidAmount")==0
 end
 -- \brief Check if item fluid storage is empty
 -- \param itemstack ItemStack
 -- \returns bool
 function industrialtest.api.isItemFluidStorageEmpty(itemstack)
 	local meta=itemstack:get_meta()
 	return industrialtest.api.isFluidStorageEmpty(meta)
 end
 -- \brief Updates itemstack description and wear depending on contained fluid
 -- \param itemstack ItemStack
 -- \returns nil
 function industrialtest.api.updateItemFluidText(itemstack)
 	local meta=itemstack:get_meta()
 	local def=itemstack:get_definition()
 	meta:set_string("description",S("@1\n@2 / @3 mB",def.description,meta:get_int("industrialtest.fluidAmount"),meta:get_int("industrialtest.fluidCapacity")))
 	itemstack:set_wear(65535-meta:get_int("industrialtest.fluidAmount")/meta:get_int("industrialtest.fluidCapacity")*65534)
 end
 -- \brief Adds fluid amount to item fluid storage
 -- \param itemstack ItemStack
 -- \param amount number
 -- \returns number
 function industrialtest.api.addFluidToItem(itemstack,amount)
 	local meta=itemstack:get_meta()
 	if not industrialtest.api.itemHasFluidStorage(itemstack) then
 		return 0
 	end
 	local fluidAmount=meta:get_int("industrialtest.fluidAmount")
 	local fluidCapacity=meta:get_int("industrialtest.fluidCapacity")
 	local prevFluidAmount=fluidAmount
 	fluidAmount=industrialtest.internal.clamp(fluidAmount+amount,0,fluidCapacity)
 	meta:set_int("industrialtest.fluidAmount",fluidAmount)
 	industrialtest.api.updateItemFluidText(itemstack)
 	return fluidAmount-prevFluidAmount
 end
 -- \brief Adds fluid to destination itemstack while subtracting it from source itemstack's metadata
 -- \param srcItemstack ItemStack
 -- \param itemstack ItemStack
 -- \param amount number
 -- \returns number
 function industrialtest.api.transferFluidToItem(srcItemstack,itemstack,amount)
 	local meta=srcItemstack:get_meta()
 	local flow=math.min(meta:get_int("industrialtest.fluidAmount"),amount)
 	if flow==0 then
 		return 0
 	end
 	local actualFlow=industrialtest.api.addFluidToItem(itemstack,flow)
 	meta:set_int("industrialtest.fluidAmount",meta:get_int("industrialtest.fluidAmount")-actualFlow)
 	industrialtest.api.updateItemFluidText(srcItemstack)
 	return actualFlow
 end
--- a/api/network.lua
+++ b/api/network.lua
@@ -0,0 +1,307 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local function addNodeToNetwork(pos,networkMasterPos)
 	local meta=minetest.get_meta(pos)
 	local networks={}
 	if meta:contains("industrialtest.networks") then
 		networks=minetest.deserialize(meta:get_string("industrialtest.networks"))
 	end
 	for _,network in ipairs(networks) do
 		if network.x==networkMasterPos.x and network.y==networkMasterPos.y and network.z==networkMasterPos.z then
 			return
 		end
 	end
 	table.insert(networks,networkMasterPos)
 	meta:set_string("industrialtest.networks",minetest.serialize(networks))
 end
 local function clampFlow(pos,flow)
 	local def=minetest.registered_nodes[minetest.get_node(pos).name]
 	local newFlow
 	if def.groups and def.groups._industrialtest_cable then
 		newFlow=def._industrialtest_cableFlow
 	else
 		local meta=minetest.get_meta(pos)
 		newFlow=meta:get_int("industrialtest.powerFlow")
 	end
 	return math.min(flow,newFlow)
 end
 -- \brief Transfers power from source node to it's network, if sides is set then power will be only transfered to network connected to that sides
 -- \param pos Vector with position of source node
 -- \param (optional) sides table with Vectors
 -- \param (optional) flowOverride number
 -- \returns two values: true if any neighbouring node has room for more power, false otherwise
 --                      true if any power was transferred, false otherwise
 function industrialtest.api.powerFlow(pos,sides,flowOverride)
 	local meta=minetest.get_meta(pos)
 	-- if machine doesn't have network map then it's not capable of transferring power
 	local network=industrialtest.api.getNetwork(meta)
 	if not network or #network==0 then
 		return false,false
 	end
 	local endpointCount=0
 	for _,endpoint in ipairs(network) do
 		local endpointMeta=minetest.get_meta(endpoint.position)
 		if not industrialtest.api.isFullyCharged(endpointMeta) and (not sides or sides[endpoint.sourceSide]) then
 			endpointCount=endpointCount+1
 		end
 	end
 	if endpointCount==0 then
 		return false,false
 	end
 	local ioConfig=industrialtest.api.getIoConfig(meta)
 	local transferred=false
 	local roomAvailable=false
 	for _,endpoint in ipairs(network) do
 		if not sides or sides[endpoint.sourceSide] then
 			local flow
 			if flowOverride then
 				flow=flowOverride
 			elseif type(ioConfig)=="string" then
 				flow=math.min(meta:get_int("industrialtest.powerAmount"),meta:get_int("industrialtest.powerFlow"))
 			else
 				flow=math.min(meta:get_int("industrialtest.powerAmount"),ioConfig[endpoint.sourceSide].flow)
 			end
 			local powerDistribution=math.floor(flow/endpointCount)
 			local endpointMeta=minetest.get_meta(endpoint.position)
 			if powerDistribution<=endpoint.flow then
 				local transferredPower=industrialtest.api.transferPower(meta,endpointMeta,powerDistribution)
 				if transferredPower>0 then
 					transferred=true
 				end
 				local def=minetest.registered_nodes[minetest.get_node(endpoint.position).name]
 				if def and def._industrialtest_self then
 					def._industrialtest_self:updateFormspec(endpoint.position)
 					if def._industrialtest_self.onPowerFlow and transferredPower>0 then
 						def._industrialtest_self:onPowerFlow(endpoint.position,industrialtest.api.getOppositeSide(endpoint.side),transferredPower)
 					end
 					def._industrialtest_self:triggerIfNeeded(endpoint.position)
 				else
 					-- Support for bare definitions that don't use industrialtest pseudo-OOP
 					minetest.get_node_timer(endpoint.position):start(industrialtest.updateDelay)
 				end
 				if not industrialtest.api.isFullyCharged(endpointMeta) then
 					roomAvailable=true
 				end
 			else
 				minetest.remove_node(endpoint.position)
 				industrialtest.internal.explode(endpoint.position,2)
 			end
 		end
 	end
 	return roomAvailable,transferred
 end
 -- \brief Creates network map starting from node at pos, optionally omitting node at omit
 -- \param pos vector
 -- \param (optional) addCables bool
 -- \param (optional) omit Vector
 -- \returns table with network map
 function industrialtest.api.createNetworkMap(pos,addCables,omit)
 	local map={}
 	local connections=industrialtest.api.getConnections(pos,"i")
 	if #connections==0 then
 		return map
 	end
 	local sourceMeta=minetest.get_meta(pos)
 	local workers={}
 	local sides={
 		["-1,0,0"]=1,
 		["1,0,0"]=2,
 		["0,-1,0"]=3,
 		["0,1,0"]=4,
 		["0,0,-1"]=5,
 		["0,0,1"]=6
 	}
 	local serializedSourcePos=pos.x..","..pos.y..","..pos.z
 	local visitedNodes={[serializedSourcePos]=true}
 	for _,conn in ipairs(connections) do
 		if not omit or conn.x~=omit.x or conn.y~=omit.y or conn.z~=omit.z then
 			local sideVector=vector.subtract(conn,pos)
 			local serializedSideVector=sideVector.x..","..sideVector.y..","..sideVector.z
 			local sourceSide=industrialtest.api.normalizeSide(pos,sides[serializedSideVector])
 			table.insert(workers,{
 				position=conn,
 				direction=sideVector,
 				distance=1,
 				flow=industrialtest.api.getPowerFlowForSide(sourceMeta,sourceSide),
 				sourceSide=sourceSide
 			})
 		end
 	end
 	while #workers>0 do
 		for i=1,#workers do
 			local worker=workers[i]
 			local serializedPos=worker.position.x..","..worker.position.y..","..worker.position.z
 			if visitedNodes[serializedPos] or (omit and omit==worker.position) then
 				table.remove(workers,i)
 				break
 			end
 			visitedNodes[serializedPos]=true
 			addNodeToNetwork(worker.position,pos)
 			local def=minetest.registered_nodes[minetest.get_node(worker.position).name]
 			if def and def.groups and def.groups._industrialtest_cable then
 				if addCables then
 					table.insert(map,{
 						position=worker.position,
 						distance=worker.distance,
 						flow=clampFlow(worker.position,worker.flow),
 						side=0,
 						sourceSide=worker.sourceSide
 					})
 				end
 				connections=industrialtest.api.getConnections(worker.position,"i")
 				if #connections==0 then
 					table.remove(workers,i)
 					break
 				end
 				worker.flow=clampFlow(worker.position,worker.flow)
 				worker.distance=worker.distance+1
 				for i=2,#connections do
 					table.insert(workers,{
 						position=connections[i],
 						direction=vector.subtract(connections[i],worker.position),
 						distance=worker.distance,
 						flow=worker.flow,
 						sourceSide=worker.sourceSide
 					})
 				end
 				worker.direction=vector.subtract(connections[1],worker.position)
 				worker.position=connections[1]
 				if #connections>=2 then
 					break
 				end
 			else
 				local meta=minetest.get_meta(worker.position)
 				local incomingSide=industrialtest.api.normalizeSide(worker.position,sides[worker.direction.x..","..worker.direction.y..","..worker.direction.z])
 				local connectionSide=industrialtest.api.getOppositeSide(incomingSide)
 				local flow=industrialtest.api.getPowerFlowForSide(meta,connectionSide)
 				table.insert(map,{
 					position=worker.position,
 					distance=worker.distance,
 					flow=math.min(worker.flow,flow),
 					side=connectionSide,
 					sourceSide=worker.sourceSide
 				})
 				table.remove(workers,i)
 				break
 			end
 		end
 	end
 	return map
 end
 function industrialtest.api.removeNodeFromNetwork(pos,nodePos)
 	local meta=minetest.get_meta(pos)
 	if not meta:contains("industrialtest.network") then
 		return
 	end
 	local network=minetest.deserialize(meta:get_string("industrialtest.network"))
 	local removed=false
 	for key,node in ipairs(network) do
 		if node.position.x==nodePos.x and node.position.y==nodePos.y and node.position.z==nodePos.z then
 			table.remove(network,key)
 			removed=true
 			break
 		end
 	end
 	if removed then
 		meta:set_string("industrialtest.network",minetest.serialize(network))
 	end
 end
 -- \brief Creates network map and writes it to node metadata at pos, optionally omitting node at omit
 -- \param pos Vector
 -- \param (optional) omit Vector
 -- \returns nil
 function industrialtest.api.createNetworkMapForNode(pos,omit)
 	local meta=minetest.get_meta(pos)
 	local network=industrialtest.api.createNetworkMap(pos,false,omit)
 	meta:set_string("industrialtest.network",minetest.serialize(network))
 end
 -- \brief Returns true if meta contains network map, false otherwise
 -- \param meta MetaDataRef
 -- \returns bool
 function industrialtest.api.isNetworkMaster(meta)
 	return meta:contains("industrialtest.network")
 end
 -- \brief Returns network table if node containing meta belongs to any networks, false otherwise
 -- \param meta MetaDataRef
 -- \returns bool or table
 function industrialtest.api.isAttachedToNetwork(meta)
 	if not meta:contains("industrialtest.networks") then
 		return false
 	end
 	local networks=minetest.deserialize(meta:get_string("industrialtest.networks"))
 	if #networks==0 then
 		return false
 	end
 	return networks
 end
 -- \brief Returns network master network from it's meta, if meta doesn't contain network map then function returns false
 -- \param meta MetaDataRef
 -- \returns table or bool
 function industrialtest.api.getNetwork(meta)
 	if not meta:contains("industrialtest.network") then
 		return false
 	end
 	return minetest.deserialize(meta:get_string("industrialtest.network"))
 end
 -- \brief Returns connections of node with power storage. If direction is "i" only input connections will be returned, if direction is "o" only output connections
 --        will be returned, if it's not provided all connections will be returned.
 -- \param pos Vector
 -- \param (optional) direction string
 -- \returns table
 function industrialtest.api.getConnections(pos,direction)
 	local result={}
 	local neighbourPositions={
 		vector.offset(pos,-1,0,0),
 		vector.offset(pos,1,0,0),
 		vector.offset(pos,0,-1,0),
 		vector.offset(pos,0,1,0),
 		vector.offset(pos,0,0,-1),
 		vector.offset(pos,0,0,1)
 	}
 	local sourceMeta=minetest.get_meta(pos)
 	local sourceDef=minetest.registered_nodes[minetest.get_node(pos).name]
 	local directionOutput=(not direction or direction=="o")
 	local directionInput=(not direction or direction=="i")
 	for key,conn in ipairs(neighbourPositions) do
 		local meta=minetest.get_meta(conn)
 		local def=minetest.registered_nodes[minetest.get_node(conn).name]
 		local normalizedKey=industrialtest.api.normalizeSide(pos,key)
 		local powerOutput=(sourceDef.groups._industrialtest_cable or industrialtest.api.isPowerOutput(sourceMeta,normalizedKey))
 		local powerInput=(sourceDef.groups._industrialtest_cable or industrialtest.api.isPowerInput(sourceMeta,normalizedKey))
 		if def.groups._industrialtest_cable or industrialtest.api.hasPowerStorage(meta) then
 			local side=industrialtest.api.normalizeSide(conn,industrialtest.api.getOppositeSide(key))
 			if (powerOutput and directionInput and (def.groups._industrialtest_cable or industrialtest.api.isPowerInput(meta,side))) or ((def.groups._industrialtest_cable or industrialtest.api.isPowerOutput(meta,side)) and powerInput and directionOutput) then
 				table.insert(result,conn)
 			end
 		end
 	end
 	return result
 end
--- a/api/power.lua
+++ b/api/power.lua
@@ -0,0 +1,211 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
 -- \brief Adds power storage to metadata
 -- \param capacity How much EU item/node can store
 -- \param flow How much EU can flow in or out item/node per industrialtest.updateDelay
 -- \param ioConfig Input/Output configuration in following side order: -X, +X, -Y, +Y, -Z, +Z
 --                 a - bidirectional, i - input, o - output.
 --                 Instead of string containing IO mode for each side, ioConfig can hold a table for each side, containing
 --                 IO mode and flow override
 -- \returns nil
 function industrialtest.api.addPowerStorage(meta,capacity,flow,ioConfig)
 	meta:set_int("industrialtest.powerCapacity",capacity)
 	meta:set_int("industrialtest.powerFlow",flow)
 	meta:set_int("industrialtest.powerAmount",0)
 	meta:set_int("industrialtest.extendedIoConfig",type(ioConfig)~="string" and 1 or 0)
 	meta:set_string("industrialtest.ioConfig",type(ioConfig)=="string" and ioConfig or minetest.serialize(ioConfig))
 end
 -- \brief Checks if metadata contains power storage
 -- \param meta MetaDataRef which should be checked
 -- \returns true if metadata contains power storage, false otherwise
 function industrialtest.api.hasPowerStorage(meta)
 	local values={"industrialtest.powerCapacity","industrialtest.powerFlow","industrialtest.powerAmount","industrialtest.ioConfig"}
 	for _,value in ipairs(values) do
 		if not meta:contains(value) then
 			return false
 		end
 	end
 	return true
 end
 -- \brief Checks if ioConfig from metadata is extended one. It exploits the fact that minetest.serialize returns Lua code
 --        which returns table, hence it can check for return at the beginning of the string
 -- \param meta MetaDataRef
 -- \returns bool
 function industrialtest.api.isExtendedIoConfig(meta)
 	return meta:get_int("industrialtest.extendedIoConfig")==1
 end
 -- \brief Returns ioConfig from metadata, deserializing it if it's extended one
 -- \param meta MetaDataRef
 -- \returns table or string
 function industrialtest.api.getIoConfig(meta)
 	local ioConfig=meta:get_string("industrialtest.ioConfig")
 	return industrialtest.api.isExtendedIoConfig(meta) and minetest.deserialize(ioConfig) or ioConfig
 end
 -- \brief Changes node's power IO config. Function doesn't check if meta actually contains power storage.
 -- \param meta MetaDataRef of node which power IO config should be changed
 -- \param side Side number. See industrialtest.api.addPowerStorage to check order.
 -- \param mode Side mode. See industrialtest.api.addPowerStorage for possible values.
 -- \returns nil
 function industrialtest.api.changeIoConfig(meta,side,mode)
 	local ioConfig=industrialtest.api.getIoConfig(meta)
 	if type(ioConfig)=="string" then
 		ioConfig=string.sub(ioConfig,1,side-1)..mode..string.sub(ioConfig,side+1)
 		meta:set_string("industrialtest.ioConfig",ioConfig)
 	else
 		ioConfig[side]=mode
 		meta:set_string("industrialtest.ioConfig",minetest.serialize(ioConfig))
 	end
 end
 -- \brief Returns power flow for side
 -- \param meta MetaDataRef
 -- \param side number Side number
 -- \returns number
 function industrialtest.api.getPowerFlowForSide(meta,side)
 	local ioConfig=industrialtest.api.getIoConfig(meta)
 	if type(ioConfig)=="string" then
 		return meta:get_int("industrialtest.powerFlow")
 	else
 		return ioConfig[side].flow
 	end
 end
 -- \brief Checks if provided side is power input
 -- \param meta MetaDataRef of node
 -- \param side Side number. See industrialtest.api.addPowerStorage to check order.
 -- \returns true if provided side is power input, false otherwise
 function industrialtest.api.isPowerInput(meta,side)
 	local ioConfig=industrialtest.api.getIoConfig(meta)
 	if type(ioConfig)=="string" then
 		local mode=string.sub(ioConfig,side,side)
 		return (mode=="i" or mode=="a")
 	else
 		return (ioConfig[side].mode=="i" or ioConfig[side].mode=="a")
 	end
 end
 -- \brief Checks if provided side is power output
 -- \param meta MetaDataRef of node
 -- \param side Side number. See industrialtest.api.addPowerStorage to check order.
 -- \returns true if provided side is power output, false otherwise
 function industrialtest.api.isPowerOutput(meta,side)
 	local ioConfig=industrialtest.api.getIoConfig(meta)
 	if type(ioConfig)=="string" then
 		local mode=string.sub(ioConfig,side,side)
 		return (mode=="o" or mode=="a")
 	else
 		return (ioConfig[side].mode=="o" or ioConfig[side].mode=="a")
 	end
 end
 -- \brief Checks if power storage is fully charged
 -- \param meta MetaDataRef which should be checked
 -- \returns true if power storage is fully charged, false otherwise
 function industrialtest.api.isFullyCharged(meta)
 	return meta:get_int("industrialtest.powerAmount")>=meta:get_int("industrialtest.powerCapacity")
 end
 -- \brief Adds power to power storage. Function doesn't check if meta contains power storage so you must be sure that it does.
 -- \param meta MetaDataRef to which power should be added
 -- \param amount Amount of power to add
 -- \returns How much of power was actually added
 function industrialtest.api.addPower(meta,amount)
 	local powerAmount=meta:get_int("industrialtest.powerAmount")
 	local powerCapacity=meta:get_int("industrialtest.powerCapacity")
 	local prevPowerAmount=powerAmount
 	powerAmount=industrialtest.internal.clamp(powerAmount+amount,0,powerCapacity)
 	meta:set_int("industrialtest.powerAmount",powerAmount)
 	return powerAmount-prevPowerAmount
 end
 -- \brief Adds power to destination metadata while subtracting it from source metadata
 -- \Param srcMeta MetaDataRef from which take power
 -- \param destMeta MetaDataRef to which add power
 -- \returns How much of power was actually transferred
 function industrialtest.api.transferPower(srcMeta,destMeta,amount)
 	local currentFlow=math.min(srcMeta:get_int("industrialtest.powerAmount"),amount)
 	if currentFlow==0 then
 		return 0
 	end
 	local actualFlow=industrialtest.api.addPower(destMeta,currentFlow)
 	srcMeta:set_int("industrialtest.powerAmount",srcMeta:get_int("industrialtest.powerAmount")-actualFlow)
 	return actualFlow
 end
 -- \brief Updates itemstack description to show current power storage information, additionally updates item wear bar.
 --        Function doesn't check if itemstack contains power storage so you should be sure that it does before calling this function
 -- \param itemstack ItemStack which should be updated
 -- \returns nil
 function industrialtest.api.updateItemPowerText(itemstack)
 	local meta=itemstack:get_meta()
 	local def=minetest.registered_tools[itemstack:get_name()]
 	local desc=meta:contains("industrialtest.descriptionOverride") and meta:get_string("industrialtest.descriptionOverride") or def.description
 	meta:set_string("description",S("@1\n@2 / @3 EU",desc,meta:get_int("industrialtest.powerAmount"),meta:get_int("industrialtest.powerCapacity")))
 	itemstack:set_wear(65535-meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*65534)
 end
 -- \brief Adds power to itemstack. Function checks if itemstack has power storage.
 -- \param itemstack ItemStack to which add power
 -- \param amount How much power to add
 -- \returns Amount of power added
 function industrialtest.api.addPowerToItem(itemstack,amount)
 	local meta=itemstack:get_meta()
 	if not industrialtest.api.hasPowerStorage(meta) then
 		return 0
 	end
 	local added=industrialtest.api.addPower(meta,amount)
 	industrialtest.api.updateItemPowerText(itemstack)
 	return added
 end
 -- \brief Adds power to destination itemstack while subtracting it from source metadata
 -- \param srcMeta MetaDataRef from which take power
 -- \param itemstack ItemStack to which add power
 -- \param amount number
 -- \returns How much of power was actually transferred
 function industrialtest.api.transferPowerToItem(srcMeta,itemstack,amount)
 	local currentFlow=math.min(srcMeta:get_int("industrialtest.powerAmount"),amount)
 	if currentFlow==0 then
 		return 0
 	end
 	local actualFlow=industrialtest.api.addPowerToItem(itemstack,currentFlow)
 	srcMeta:set_int("industrialtest.powerAmount",srcMeta:get_int("industrialtest.powerAmount")-actualFlow)
 	return actualFlow
 end
 -- \brief Adds power to destination metadata while subtracting it from source itemstack
 -- \param srcItemstack ItemStack from which subtract power
 -- \param meta MetaDataRef to which add power
 -- \param amount How much power should be transferred
 -- \returns How much of power was actually transferred
 function industrialtest.api.transferPowerFromItem(srcItemstack,meta,amount)
 	local srcMeta=srcItemstack:get_meta()
 	local currentFlow=math.min(srcMeta:get_int("industrialtest.powerAmount"),amount)
 	if currentFlow==0 then
 		return 0
 	end
 	local actualFlow=industrialtest.api.addPower(meta,currentFlow)
 	industrialtest.api.addPowerToItem(srcItemstack,-actualFlow)
 	return actualFlow
 end
--- a/api/registration.lua
+++ b/api/registration.lua
@@ -0,0 +1,323 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
 function industrialtest.api.addTag(name,tag)
 	if not industrialtest.api.tags[tag] then
 		industrialtest.api.tags[tag]={}
 	end
 	table.insert(industrialtest.api.tags[tag],name)
 end
 -- \brief Registers dust of certain resource
 -- \param name Technical name of resource
 -- \param displayName Display name of resource
 -- \param resources List of tables with following keys: <output>, <recipe>, [count(1)]
 --                                                      <> - required, [] - optional, () - default value
 -- \param color HTML color of dust
 -- \param registerMaceratorRecipe If true macerator recipe for dust will be registered
 -- \returns nil
 function industrialtest.api.registerResourceDust(name,displayName,resources,color,registerMaceratorRecipe)
 	minetest.register_craftitem("industrialtest:"..name.."_dust",{
 		description=S(displayName.." Dust"),
 		inventory_image="industrialtest_dust.png",
 		color=color
 	})
 	if registerMaceratorRecipe then
 		for _,value in ipairs(resources) do
 			industrialtest.api.registerMaceratorRecipe({
 				output="industrialtest:"..name.."_dust "..(value.count or 1),
 				recipe=value.resource
 			})
 		end
 	end
 end
 -- \brief Registers plate of certain resource
 -- \param name Technical name of resource
 -- \param displayName Display name of resource
 -- \param resources List of tables with following keys: <output>, <recipe>, [count(1)]
 --                                                      <> - required, [] - optional, () - default value
 -- \param color HTML color of plate
 -- \param registerCompressorRecipe If true compressor recipe for plate will be registered
 -- \returns nil
 function industrialtest.api.registerPlate(name,displayName,resources,color,registerCompressorRecipe)
 	minetest.register_craftitem("industrialtest:"..name,{
 		description=displayName,
 		inventory_image="industrialtest_plate.png",
 		inventory_overlay="industrialtest_plate_overlay.png",
 		color=color
 	})
 	if registerCompressorRecipe then
 		for _,value in ipairs(resources) do
 			industrialtest.api.registerCompressorRecipe({
 				output="industrialtest:"..name.." "..(value.count or 1),
 				recipe=value.resource
 			})
 		end
 	end
 end
 -- \brief Registers cell with certain fluid
 -- \param name Technical name of cell
 -- \param displayName Display name of cell
 -- \param node Node which can be picked up with this cell
 -- \returns nil
 function industrialtest.api.registerStorageCell(name,displayName,node,modname,color)
 	color = color or "#ffffffff"
 	if not modname then
 		modname="industrialtest"
 	end
 	minetest.register_craftitem("industrialtest:"..name.."_cell",{
 		description=S(displayName.." Cell"),
 		inventory_image="industrialtest_cell_fluid.png",
 		inventory_overlay="industrialtest_cell_casing.png",
 		color=color,
 		on_place=function(itemstack,user,pointed)
 			if pointed.type~="node" or not user or not user:is_player() then
 				return nil
 			end
 			local node=minetest.get_node_or_nil(pointed.above)
 			local storage=industrialtest.api.getStorageCell("industrialtest:"..name.."_cell")
 			if storage.node then
 				if node.name~="air" and node.name~=storage.node then
 					return nil
 				end
 				minetest.set_node(pointed.above,{name=storage.node})
 				if itemstack:get_count()==1 then
 					itemstack:set_name("industrialtest:empty_cell")
 				else
 					local inv=user:get_inventory()
 					inv:add_item("main",ItemStack("industrialtest:empty_cell"))
 					itemstack:take_item()
 				end
 				return itemstack
 			end
 			return nil
 		end
 	})
 	industrialtest.api.storageCells["industrialtest:"..name.."_cell"]={
 		name="industrialtest:"..name.."_cell",
 		node=node
 	}
 end
 -- \brief Returns registred storage cell by name
 -- \param name Storage cell name
 -- \returns Table with following keys: name, node or nil in case of failure
 function industrialtest.api.getStorageCell(name)
 	return industrialtest.api.storageCells[name]
 end
 -- \brief Returns registered storage cells by node
 -- \param node Node ID
 -- \returns Table with following keys: name, node or nil in case of failure
 function industrialtest.api.getStorageCellByNode(node)
 	for _,value in pairs(industrialtest.api.storageCells) do
 		if value.node==node then
 			return value
 		end
 	end
 	return nil
 end
 -- \brief Registers macerator recipe
 -- \param config Table with keys: <output>, <recipe>, [time(2)]
 -- \returns nil
 function industrialtest.api.registerMaceratorRecipe(config)
 	local definition={
 		output=config.output or "",
 		recipe=config.recipe or "",
 		time=config.time or 2
 	}
 	industrialtest.api.maceratorRecipes[definition.recipe]=definition
 end
 -- \brief Returns macerator recipe result
 -- \param recipe String ID of resulting conten
 -- \returns Table with following keys: output, recipe, time
 function industrialtest.api.getMaceratorRecipeResult(recipe)
 	return industrialtest.api.maceratorRecipes[recipe]
 end
 -- \brief Registers compressor recipe
 -- \param config Table with following keys: <output>, <recipe>, [time(2)], [count(1)]
 -- \returns nil
 function industrialtest.api.registerCompressorRecipe(config)
 	local definition={
 		output=config.output or "",
 		recipe=config.recipe or "",
 		time=config.time or 2,
 		count=config.count or 1
 	}
 	industrialtest.api.compressorRecipes[definition.recipe]=definition
 end
 -- \brief Returns macerator recipe result
 -- \param recipe String ID of resulting conten
 -- \returns Table with following keys: output, recipe, time
 function industrialtest.api.getCompressorRecipeResult(recipe)
 	return industrialtest.api.compressorRecipes[recipe]
 end
 function industrialtest.api.registerExtractorRecipe(config)
 	local definition={
 		output=config.output or "",
 		recipe=config.recipe or "",
 		time=config.time or 2
 	}
 	industrialtest.api.extractorRecipes[definition.recipe]=definition
 end
 function industrialtest.api.getExtractorRecipeResult(recipe)
 	return industrialtest.api.extractorRecipes[recipe]
 end
 function industrialtest.api.registerCableFormerRecipe(config)
 	local definition={
 		output=config.output or "",
 		recipe=config.recipe or "",
 		time=config.time or 2
 	}
 	industrialtest.api.cableFormerRecipes[definition.recipe]=definition
 end
 function industrialtest.api.getCableFormerRecipeResult(recipe)
 	return industrialtest.api.cableFormerRecipes[recipe]
 end
 -- \brief Registers fuel that can be used in geothermal generator
 -- \param fuel Table with following keys: <name>, <calorificValue>, <storageItems>
 --        which is a table containing items which are tables with following keys: <name>, <leftover>
 -- \returns nil
 function industrialtest.api.registerGeothermalGeneratorFuel(config)
 	local definition={
 		name=config.name or "",
 		calorificValue=config.calorificValue or 0,
 		texture=config.texture or "industrialtest_gui_fluid_bg.png",
 		storageItems=config.storageItems or {}
 	}
 	industrialtest.api.geothermalGeneratorFuels[definition.name]=definition
 end
 -- \brief Returns generator fuel information
 -- \param name Name of fuel
 -- \returns Table with following keys: name, calorificValue, storageItems
 function industrialtest.api.getGeothermalGeneratorFuel(name)
 	return industrialtest.api.geothermalGeneratorFuels[name]
 end
 -- \brief Returns generator fuel information by item name
 -- \param name ID of item
 -- \returns Table with following keys: name, calorificValue, storageItems or nil in case of failure
 function industrialtest.api.getGeothermalGeneratorFuelByItem(name)
 	for _,value in pairs(industrialtest.api.geothermalGeneratorFuels) do
 		for _,item in ipairs(value.storageItems) do
 			if item.name==name then
 				return value
 			end
 		end
 	end
 	return nil
 end
 -- \brief Registers fuel that can be used in water mill
 -- \param fuel Table with following keys: <name>, <calorificValue>, <storageItems>
 --        which is a table containing items which are tables with following keys: <name>, <leftover>
 -- \returns nil
 function industrialtest.api.registerWaterMillFuel(config)
 	local definition={
 		name=config.name or "",
 		calorificValue=config.calorificValue or 0,
 		texture=config.texture or "industrialtest_gui_fluid_bg.png",
 		storageItems=config.storageItems or {}
 	}
 	industrialtest.api.waterMillFuels[definition.name]=definition
 end
 -- \brief Returns water mill fuel information
 -- \param name Name of fuel
 -- \returns Table with following keys: name, calorificValue, storageItems
 function industrialtest.api.getWaterMillFuel(name)
 	return industrialtest.api.waterMillFuels[name]
 end
 -- \brief Returns water mill fuel information by item name
 -- \param name ID of item
 -- \returns Table with following keys: name, calorificValue, storageItems or nil in case of failure
 function industrialtest.api.getWaterMillFuelByItem(name)
 	for _,value in pairs(industrialtest.api.waterMillFuels) do
 		for _,item in ipairs(value.storageItems) do
 			if item.name==name then
 				return value
 			end
 		end
 	end
 	return nil
 end
 -- \brief Registers Rotary Macerator recipe modifier
 -- \param config table
 -- \param omitPlaceholder bool, for internal use only
 -- \returns nil
 function industrialtest.api.registerRotaryMaceratorModifier(config,omitPlaceholder)
 	local definition={
 		name=config.name or "",
 		modifier=config.modifier or "",
 		output=config.output or "",
 		time=config.time or 2,
 		uses=config.uses or 1,
 		modifierLeftover=config.modifierLeftover
 	}
 	if not omitPlaceholder and not config.modifierLeftover and string.len(definition.modifier)>0 then
 		local delimiter,_=string.find(definition.modifier,":")
 		definition.stackLeftover="industrialtest:"..string.sub(definition.modifier,1,delimiter-1).."_"..string.sub(definition.modifier,delimiter+1,-1).."_leftover"
 		industrialtest.api.registerRotaryMaceratorModifier({
 			name=definition.name,
 			modifier=definition.stackLeftover,
 			output=definition.output,
 			time=definition.time,
 			uses=definition.uses
 		},true)
 	end
 	industrialtest.api.rotaryMaceratorModifiers[definition.name.." "..config.modifier]=definition
 end
 -- \brief Returns modified Rotary Macerator recipe by item and modifier
 -- \param name string
 -- \param modifier string
 -- \returns table
 function industrialtest.api.getRotaryMaceratorModifier(name,modifier)
 	return industrialtest.api.rotaryMaceratorModifiers[name.." "..modifier]
 end
 minetest.register_on_mods_loaded(function()
 	for _,def in pairs(industrialtest.api.rotaryMaceratorModifiers) do
 		if def.stackLeftover then
 			local leftoverDef=table.copy(minetest.registered_items[def.modifier])
 			leftoverDef.groups=leftoverDef.groups or {}
 			leftoverDef.groups.not_in_creative_inventory=1
 			if industrialtest.mclAvailable then
 				leftoverDef._doc_items_create_entry=false
 			end
 			-- Item name starts with : to prevent name checks, because it seems to fail in on_mods_loaded
 			minetest.register_craftitem(":"..def.stackLeftover,leftoverDef)
 		end
 	end
 end)
--- a/api/side.lua
+++ b/api/side.lua
@@ -0,0 +1,49 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 -- \brief Takes rotated node and side and outputs normalized side that can be used for ioConfig lookups
 -- \param pos Vector with node position
 -- \param side Node side. See industrialtest.api.addPowerStorage for possible values
 -- \returns Normalized side or in case of failure side argument back
 function industrialtest.api.normalizeSide(pos,side)
 	local node=minetest.get_node(pos)
 	-- FIXME: improve code quality there
 	local translation={
 		[0]={
 			1,2,3,4,5,6
 		},
 		[1]={
 			5,6,3,4,1,2
 		},
 		[2]={
 			2,1,3,4,6,5
 		},
 		[3]={
 			6,5,3,4,2,1
 		}
 	}
 	if node.param2>3 then
 		return side
 	end
 	return translation[node.param2][side]
 end
 -- \brief Returns opposite side of provided one
 -- \param side Side number. See industrialtest.api.addPowerStorage for order
 -- \returns Opposite side
 function industrialtest.api.getOppositeSide(side)
 	return (side%2==0 and side-1 or side+1)
 end
--- a/cables.lua
+++ b/cables.lua
@@ -130,7 +130,10 @@ local function registerCable(name,displayName,size,flow,registerInsulated)
 		}
 		definition.sound=default.node_sound_metal_defaults()
 	elseif industrialtest.mclAvailable then
-		definition.groups={pickaxey=1}
+		definition.groups={
 			handy=1,
 			pickaxey=1
 		}
 		definition._mcl_blast_resistance=1
 		definition._mcl_hardness=0.5
 		definition.sound=mcl_sounds.node_sound_metal_defaults()
@@ -160,16 +163,16 @@ minetest.register_craft({
 	output="industrialtest:insulated_tin_cable",
 	recipe={
 		"industrialtest:tin_cable",
-		"industrialtest:rubber"
+		industrialtest.elementKeys.rubber
 	}
 })
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:insulated_tin_cable 6",
 	recipe={
-		{"industrialtest:rubber","industrialtest:rubber","industrialtest:rubber"},
+		{industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber},
 		{industrialtest.elementKeys.tinIngot,industrialtest.elementKeys.tinIngot,industrialtest.elementKeys.tinIngot},
-		{"industrialtest:rubber","industrialtest:rubber","industrialtest:rubber"}
+		{industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber}
 	}
 })
 industrialtest.api.registerCableFormerRecipe({
@@ -191,16 +194,16 @@ minetest.register_craft({
 	output="industrialtest:insulated_copper_cable",
 	recipe={
 		"industrialtest:copper_cable",
-		"industrialtest:rubber"
+		industrialtest.elementKeys.rubber
 	}
 })
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:insulated_copper_cable 6",
 	recipe={
-		{"industrialtest:rubber","industrialtest:rubber","industrialtest:rubber"},
+		{industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber},
 		{industrialtest.elementKeys.copperIngot,industrialtest.elementKeys.copperIngot,industrialtest.elementKeys.copperIngot},
-		{"industrialtest:rubber","industrialtest:rubber","industrialtest:rubber"}
+		{industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber}
 	}
 })
 industrialtest.api.registerCableFormerRecipe({
@@ -221,16 +224,16 @@ minetest.register_craft({
 	output="industrialtest:insulated_gold_cable",
 	recipe={
 		"industrialtest:gold_cable",
-		"industrialtest:rubber"
+		industrialtest.elementKeys.rubber
 	}
 })
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:insulated_gold_cable 6",
 	recipe={
-		{"industrialtest:rubber","industrialtest:rubber","industrialtest:rubber"},
+		{industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber},
 		{industrialtest.elementKeys.goldIngot,industrialtest.elementKeys.goldIngot,industrialtest.elementKeys.goldIngot},
-		{"industrialtest:rubber","industrialtest:rubber","industrialtest:rubber"}
+		{industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber}
 	}
 })
 industrialtest.api.registerCableFormerRecipe({
@@ -251,16 +254,16 @@ minetest.register_craft({
 	output="industrialtest:insulated_iron_cable",
 	recipe={
 		"industrialtest:iron_cable",
-		"industrialtest:rubber"
+		industrialtest.elementKeys.rubber
 	}
 })
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:insulated_iron_cable 6",
 	recipe={
-		{"industrialtest:rubber","industrialtest:rubber","industrialtest:rubber"},
+		{industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber},
 		{"industrialtest:refined_iron_ingot","industrialtest:refined_iron_ingot","industrialtest:refined_iron_ingot"},
-		{"industrialtest:rubber","industrialtest:rubber","industrialtest:rubber"}
+		{industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber}
 	}
 })
 industrialtest.api.registerCableFormerRecipe({
--- a/compat/logistica.lua
+++ b/compat/logistica.lua
@@ -0,0 +1,68 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local oldInsertItemstackForRequester=logistica.insert_itemstack_for_requester
 -- Logistica overrides
 function logistica.insert_itemstack_for_requester(requesterPos,itemstack,limitByRequest)
 	local result=oldInsertItemstackForRequester(requesterPos, itemstack, limitByRequest)
 	local targetPos=logistica.get_requester_target(requesterPos)
 	local def=minetest.registered_nodes[minetest.get_node(targetPos).name]
 	if def._logistica_afterRequesterItemstackInsert then
 		def._logistica_afterRequesterItemstackInsert(targetPos)
 	end
 	return result
 end
 local onInjectorTimer=logistica.on_timer_powered(function(pos,elapsed)
 	local result=logistica.on_injector_timer(pos,elapsed)
 	local targetPos=logistica.get_injector_target(pos)
 	local def=minetest.registered_nodes[minetest.get_node(targetPos).name]
 	if def._logistica_afterInjectorItemstackTake then
 		def._logistica_afterInjectorItemstackTake(targetPos)
 	end
 	return result
 end)
 for _,name in ipairs(logistica.group_get_all_nodes_for_group("injectors")) do
 	local override={
 		on_timer=onInjectorTimer
 	}
 	minetest.override_item(name,override)
 end
 local function afterLogisticaAction(pos)
 	local def=minetest.registered_nodes[minetest.get_node(pos).name]
 	if def and def._industrialtest_self then
 		def._industrialtest_self:triggerIfNeeded(pos)
 	end
 end
 local function addLogisticaCompatibility(name)
 	local override={
 		_logistica_afterRequesterItemstackInsert=afterLogisticaAction,
 		_logistica_afterInjectorItemstackTake=afterLogisticaAction
 	}
 	minetest.override_item(name,override)
 end
 for _,name in ipairs(industrialtest.api.tags.usesTimer) do
 	addLogisticaCompatibility(name)
 end
--- a/compat/mesecons.lua
+++ b/compat/mesecons.lua
@@ -0,0 +1,123 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 -- Rotary Macerator
 local override={
 	mesecons={
 		effector={
 			action_on=function(pos,node)
 				if node.name~="industrialtest:rotary_macerator" then
 					return
 				end
 				local meta=minetest.get_meta(pos)
 				meta:set_int("maintainSpeed",1)
 				local def=minetest.registered_nodes[node.name]
 				def._industrialtest_self:updateFormspec(pos)
 				def._industrialtest_self:trigger(pos)
 			end,
 			action_off=function(pos,node)
 				local meta=minetest.get_meta(pos)
 				meta:set_int("maintainSpeed",0)
 				local def=minetest.registered_nodes[node.name]
 				def._industrialtest_self:updateFormspec(pos)
 			end
 		}
 	}
 }
 minetest.override_item("industrialtest:rotary_macerator",override)
 minetest.override_item("industrialtest:rotary_macerator_active",override)
 -- Nuclear Reactor
 override={
 	mesecons={
 		effector={
 			action_on=function(pos,node)
 				local isChamber=node.name=="industrialtest:nuclear_reactor_chamber"
 				if node.name~="industrialtest:nuclear_reactor" and not isChamber then
 					return
 				end
 				local originalPos
 				local meta=minetest.get_meta(pos)
 				meta:set_int("meseconPowered",1)
 				if isChamber then
 					originalPos=pos
 					pos=minetest.deserialize(meta:get_string("reactor"))
 					node=minetest.get_node(pos)
 					meta=minetest.get_meta(pos)
 				end
 				meta:set_int("enabled",1)
 				meta:set_int("stateChanged",1)
 				local def=minetest.registered_nodes[node.name]
 				def._industrialtest_self:updateFormspec(pos)
 				if isChamber then
 					def._industrialtest_self:synchronizeToChamber(originalPos)
 				end
 				def._industrialtest_self:triggerIfNeeded(pos)
 			end,
 			action_off=function(pos,node)
 				local isChamber=node.name=="industrialtest:nuclear_reactor_chamber"
 				local originalPos
 				local meta=minetest.get_meta(pos)
 				meta:set_int("meseconPowered",0)
 				if isChamber then
 					originalPos=pos
 					pos=minetest.deserialize(meta:get_string("reactor"))
 					node=minetest.get_node(pos)
 					meta=minetest.get_meta(pos)
 				end
 				if meta:get_int("meseconPowered")==1 then
 					return
 				end
 				if meta:contains("chambers") then
 					local chambers=minetest.deserialize(meta:get_string("chambers"))
 					for _,chamber in ipairs(chambers) do
 						local chamberMeta=minetest.get_meta(chamber)
 						if chamberMeta:get_int("meseconPowered")==1 then
 							return
 						end
 					end
 				end
 				meta:set_int("enabled",0)
 				meta:set_int("stateChanged",1)
 				local def=minetest.registered_nodes[node.name]
 				def._industrialtest_self:updateFormspec(pos)
 				if isChamber then
 					def._industrialtest_self:synchronizeToChamber(originalPos)
 				end
 			end
 		}
 	}
 }
 minetest.override_item("industrialtest:nuclear_reactor",override)
 minetest.override_item("industrialtest:nuclear_reactor_active",override)
 -- Nuclear Reactor Chamber
 minetest.override_item("industrialtest:nuclear_reactor_chamber",override)
--- a/compat/pipeworks.lua
+++ b/compat/pipeworks.lua
@@ -0,0 +1,406 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local function getListnameBySide(sides,direction)
 	local listname
 	for _,side in ipairs(sides) do
 		if (not side.x or side.x==direction.x) and (not side.y or side.y==direction.y) and (not side.z or side.z==direction.z) then
 			listname=side.listname
 			break
 		end
 	end
 	return listname
 end
 local function addPipeworksCompatibility(name,sides,inputInventory)
 	local groups=table.copy(minetest.registered_nodes[name].groups)
 	groups.tubedevice=1
 	groups.tubedevice_receiver=1
 	local override={
 		groups=groups,
 		tube={
 			insert_object=function(pos,node,stack,direction)
 				local meta=minetest.get_meta(pos)
 				local inv=meta:get_inventory()
 				local listname=getListnameBySide(sides,direction)
 				if (listname=="charged" or listname=="discharged" or listname=="powerStorage") and not industrialtest.api.hasPowerStorage(stack:get_meta()) then
 					return nil
 				end
 				local result=inv:add_item(listname,stack)
 				local def=minetest.registered_nodes[node.name]
 				if def and def._industrialtest_self then
 					def._industrialtest_self:triggerIfNeeded(pos)
 				end
 				return result
 			end,
 			can_insert=function(pos,node,stack,direction)
 				local meta=minetest.get_meta(pos)
 				local inv=meta:get_inventory()
 				local listname=getListnameBySide(sides,direction)
 				if (listname=="charged" or listname=="discharged" or listname=="powerStorage") and not industrialtest.api.hasPowerStorage(stack:get_meta()) then
 					return false
 				end
 				return inv:room_for_item(listname,stack)
 			end,
 			remove_items=function(pos,node,stack,direction,count,listname)
 				local meta=minetest.get_meta(pos)
 				local inv=meta:get_inventory()
 				inv:remove_item(listname,stack)
 				local def=minetest.registered_nodes[node.name]
 				if def and def._industrialtest_self then
 					def._industrialtest_self:triggerIfNeeded(pos)
 				end
 				return stack
 			end,
 			input_inventory=inputInventory,
 			connect_sides={
 				left=1,
 				right=1,
 				back=1,
 				front=1,
 				bottom=1,
 				top=1
 			}
 		},
 		after_place_node=pipeworks.after_place,
 		after_dig_node=pipeworks.after_dig,
 		on_rotate=pipeworks.on_rotate
 	}
 	minetest.override_item(name,override)
 	local activeName=name.."_active"
 	if minetest.registered_nodes[activeName] then
 		minetest.override_item(activeName,override)
 	end
 end
 -- Iron Furnace
 addPipeworksCompatibility("industrialtest:iron_furnace",{
 	{
 		y=1,
 		listname="fuel"
 	},
 	{listname="src"}
 },"dst")
 -- Generator
 addPipeworksCompatibility("industrialtest:generator",{
 	{
 		y=1,
 		listname="fuel",
 	},
 	{listname="charged"}
 },"charged")
 -- Geothermal Generator
 addPipeworksCompatibility("industrialtest:geothermal_generator",{
 	{
 		y=1,
 		listname="leftover",
 	},
 	{
 		y=-1,
 		listname="fluid"
 	},
 	{listname="charged"}
 },"leftover")
 -- Water Mill
 addPipeworksCompatibility("industrialtest:water_mill",{
 	{
 		y=1,
 		listname="leftover",
 	},
 	{
 		y=-1,
 		listname="fluid"
 	},
 	{listname="charged"}
 },"leftover")
 -- Wind Mill
 addPipeworksCompatibility("industrialtest:wind_mill",{
 	{listname="charged"}
 },"charged")
 -- Solar Panel
 addPipeworksCompatibility("industrialtest:solar_panel",{
 	{listname="charged"}
 },"charged")
 addPipeworksCompatibility("industrialtest:lv_solar_array",{
 	{listname="charged"}
 },"charged")
 addPipeworksCompatibility("industrialtest:mv_solar_array",{
 	{listname="charged"}
 },"charged")
 addPipeworksCompatibility("industrialtest:hv_solar_array",{
 	{listname="charged"}
 },"charged")
 -- Nuclear Reactor
 local def=table.copy(minetest.registered_nodes["industrialtest:nuclear_reactor"])
 def.groups.tubedevice=1
 def.groups.tubedevice_receiver=1
 local override={
 	groups=def.groups,
 	tube={
 		insert_object=function(pos,node,stack,direction)
 			local listname=direction.y==0 and "charged" or "fuel"
 			local def=stack:get_definition()
 			if (listname=="charged" and not industrialtest.api.hasPowerStorage(stack:get_meta())) or
 				(listname=="fuel" and (not def.groups or not def.groups._industrialtest_placedInNuclearReactor)) then
 				return nil
 			end
 			local meta=minetest.get_meta(pos)
 			local inv=meta:get_inventory()
 			local result=inv:add_item(listname,stack)
 			industrialtest.Reactor.synchronizeChambers(pos)
 			industrialtest.Reactor:triggerIfNeeded(pos)
 			return result
 		end,
 		can_insert=function(pos,node,stack,direction)
 			local listname=direction.y==0 and "charged" or "fuel"
 			local def=stack:get_definition()
 			if (listname=="charged" and not industrialtest.api.hasPowerStorage(stack:get_meta())) or
 				(listname=="fuel" and (not def.groups or not def.groups._industrialtest_placedInNuclearReactor)) then
 				return false
 			end
 			local meta=minetest.get_meta(pos)
 			local inv=meta:get_inventory()
 			return inv:room_for_item(listname,stack)
 		end,
 		remove_items=function(pos,node,stack,direction,count,listname)
 			local meta=minetest.get_meta(pos)
 			local inv=meta:get_inventory()
 			inv:remove_item(listname,stack)
 			industrialtest.Reactor.synchronizeChambers(pos)
 			industrialtest.Reactor:triggerIfNeeded(pos)
 			return stack
 		end,
 		input_inventory="fuel",
 		connect_sides={
 			left=1,
 			right=1,
 			back=1,
 			front=1,
 			bottom=1,
 			top=1
 		}
 	},
 	after_place_node=pipeworks.after_place,
 	after_dig_node=pipeworks.after_dig,
 	on_rotate=pipeworks.on_rotate
 }
 minetest.override_item("industrialtest:nuclear_reactor",override)
 minetest.override_item("industrialtest:nuclear_reactor_active",override)
 -- Nuclear Reactor Chamber
 override=table.copy(override)
 def=table.copy(minetest.registered_nodes["industrialtest:nuclear_reactor_chamber"])
 override.groups=def.groups
 override.groups.tubedevice=1
 override.groups.tubedevice_receiver=1
 override.tube.insert_object=function(pos,node,stack,direction)
 	local listname=direction.y==0 and "charged" or "fuel"
 	local def=stack:get_definition()
 	if (listname=="charged" and not industrialtest.api.hasPowerStorage(stack:get_meta())) or
 		(listname=="fuel" and (not def.groups or not def.groups._industrialtest_placedInNuclearReactor)) then
 		return nil
 	end
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local result=inv:add_item(listname,stack)
 	industrialtest.Reactor:synchronizeToChamber(pos)
 	local reactorPos=minetest.deserialize(meta:get_string("reactor"))
 	industrialtest.Reactor:triggerIfNeeded(reactorPos)
 	return result
 end
 override.tube.remove_items=function(pos,node,stack,direction,count,listname)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	inv:remove_item(listname,stack)
 	industrialtest.Reactor:synchronizeToChamber(pos)
 	local reactorPos=minetest.deserialize(meta:get_string("reactor"))
 	industrialtest.Reactor:triggerIfNeeded(reactorPos)
 	return stack
 end
 override.after_place_node_old=def.after_place_node
 override.after_place_node=function(pos)
 	minetest.registered_nodes["industrialtest:nuclear_reactor_chamber"].after_place_node_old(pos)
 	pipeworks.after_place(pos)
 end
 minetest.override_item("industrialtest:nuclear_reactor_chamber",override)
 -- BatBox
 addPipeworksCompatibility("industrialtest:batbox",{
 	{
 		y=1,
 		listname="discharged"
 	},
 	{listname="charged"}
 },"charged")
 -- CESU
 addPipeworksCompatibility("industrialtest:cesu",{
 	{
 		y=1,
 		listname="discharged"
 	},
 	{listname="charged"}
 },"charged")
 -- MFE
 addPipeworksCompatibility("industrialtest:mfe",{
 	{
 		y=1,
 		listname="discharged"
 	},
 	{listname="charged"}
 },"charged")
 -- MFSU
 addPipeworksCompatibility("industrialtest:mfsu",{
 	{
 		y=1,
 		listname="discharged"
 	},
 	{listname="charged"}
 },"charged")
 -- Canning Machine
 def=table.copy(minetest.registered_nodes["industrialtest:canning_machine"])
 def.groups.tubedevice=1
 def.groups.tubedevice_receiver=1
 override={
 	groups=def.groups,
 	tube={
 		insert_object=function(pos,node,stack,direction)
 			local listname
 			if direction.y==1 then
 				listname="powerStorage"
 			elseif direction.y==-1 then
 				listname="src"
 			else
 				listname="dst"
 			end
 			local def=stack:get_definition()
 			if (listname=="powerStorage" and not industrialtest.api.hasPowerStorage(stack:get_meta())) or
 				(listname=="src" and (not def.groups or not def.groups._industrialtest_fuel)) or
 				(listname=="dst" and (not def.groups or not def.groups._industrialtest_fueled)) then
 				return nil
 			end
 			local meta=minetest.get_meta(pos)
 			local inv=meta:get_inventory()
 			local result=inv:add_item(listname,stack)
 			minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 			return result
 		end,
 		can_insert=function(pos,node,stack,direction)
 			local listname
 			if direction.y==1 then
 				listname="powerStorage"
 			elseif direction.y==-1 then
 				listname="src"
 			else
 				listname="dst"
 			end
 			local def=stack:get_definition()
 			if (listname=="powerStorage" and not industrialtest.api.hasPowerStorage(stack:get_meta())) or
 				(listname=="src" and (not def.groups or not def.groups._industrialtest_fuel)) or
 				(listname=="dst" and (not def.groups or not def.groups._industrialtest_fueled)) then
 				return false
 			end
 			local meta=minetest.get_meta(pos)
 			local inv=meta:get_inventory()
 			return inv:room_for_item(listname,stack)
 		end,
 		remove_items=function(pos,node,stack,direction,count,listname)
 			local meta=minetest.get_meta(pos)
 			local inv=meta:get_inventory()
 			inv:remove_item(listname,stack)
 			industrialtest.CanningMachine:triggerIfNeeded(pos)
 			return stack
 		end,
 		input_inventory="dst",
 		connect_sides={
 			left=1,
 			right=1,
 			back=1,
 			bottom=1,
 			top=1
 		}
 	},
 	after_place_node=pipeworks.after_place,
 	after_dig_node=pipeworks.after_dig,
 	on_rotate=pipeworks.on_rotate
 }
 minetest.override_item("industrialtest:canning_machine",override)
 minetest.override_item("industrialtest:canning_machine_active",override)
 -- Rotary Macerator
 addPipeworksCompatibility("industrialtest:rotary_macerator",{
 	{
 		y=1,
 		listname="powerStorage"
 	},
 	{
 		y=-1,
 		listname="src"
 	},
 	{listname="modifier"}
 },"dst")
 -- Induction Furnace
 addPipeworksCompatibility("industrialtest:induction_furnace",{
 	{
 		y=1,
 		listname="powerStorage"
 	},
 	{listname="src"}
 },"dst")
 -- Simple electric item processors
 for _,name in ipairs(industrialtest.api.tags.simpleElectricItemProcessor) do
 	addPipeworksCompatibility(name,{
 		{
 			y=1,
 			listname="powerStorage"
 		},
 		{listname="src"}
 	},"dst")
 end
 for _,name in ipairs(industrialtest.internal.chargepads) do
 	addPipeworksCompatibility(name,{
 		{
 			y=1,
 			listname="discharged"
 		},
 		{listname="charged"}
 	},"charged")
 end
--- a/compatibility.lua
+++ b/compatibility.lua
@@ -33,15 +33,26 @@ for _,mod in ipairs(requiredMclModules) do
 	end
 end
-if industrialtest.mtgAvailable and not minetest.get_modpath("3d_armor") then
+industrialtest.mods={}
 if industrialtest.mtgAvailable then
 	industrialtest.mods._3dArmor=minetest.get_modpath("3d_armor")
 elseif industrialtest.mclAvailable then
 	industrialtest.mods.mclRubber=minetest.get_modpath("mcl_rubber")
 end
 industrialtest.mods.pipeworks=minetest.get_modpath("pipeworks")
 industrialtest.mods.logistica=minetest.get_modpath("logistica")
 industrialtest.mods.mesecons=minetest.get_modpath("mesecons")
 if industrialtest.mtgAvailable and not industrialtest.mods._3dArmor then
 	error("IndustrialTest requires 3D Armor when used with Minetest Game")
 end
 industrialtest.elementKeys={}
 industrialtest.internal={}
 if industrialtest.mclAvailable then
 	industrialtest.stackMax=64
 	industrialtest.internal.mclMakeStrippedTrunk=function(itemstack,placer,pointedThing,electricTool)
 		-- Taken from https://git.minetest.land/MineClone2/MineClone2/src/branch/master/mods/ITEMS/mcl_tools/init.lua#L360
 		if pointedThing.type ~= "node" then return end
@@ -70,12 +81,27 @@ if industrialtest.mclAvailable then
 		end
 		return itemstack
 	end
-	industrialtest.internal.explode=mcl_explosions.explode
+
 	industrialtest.internal.explode=function(pos,radius,dropChance)
 		mcl_explosions.explode(pos,radius,{drop_chance=dropChance})
 	end
 	industrialtest.internal.getItemSlotBg=mcl_formspec.get_itemslot_bg
 elseif industrialtest.mtgAvailable then
 	industrialtest.stackMax=99
 	industrialtest.internal.explode=function(pos,radius)
 		tnt.boom(pos,{radius=radius})
 	end
 	industrialtest.internal.getItemSlotBg=function()
 		return ""
 	end
 end
 -- compatibilty that adds not existing elements
 if industrialtest.mclAvailable then
-	industrialtest.registerMetal=function(name,displayName,oreBlastResistance,oreHardness,rawBlockBlastResistance,rawBlockHardness,blockBlastResistance,blockHardness)
+	industrialtest.internal.registerMetal=function(name,displayName,oreBlastResistance,oreHardness,rawBlockBlastResistance,rawBlockHardness,blockBlastResistance,blockHardness)
 		minetest.register_craftitem("industrialtest:raw_"..name,{
 			description=S("Raw "..displayName),
 			inventory_image="industrialtest_mcl_raw_"..name..".png"
@@ -177,7 +203,7 @@ if industrialtest.mclAvailable then
 		minetest.register_tool("industrialtest:"..material.."_pickaxe",{
 			description=S(materialDisplayName.." Pickaxe"),
 			inventory_image="industrialtest_mcl_"..material.."_pickaxe.png",
-			groups={tool=1,pickaxe=1,dig_speed_class=config.digSpeedClass},
+			groups={tool=1,pickaxe=1,dig_speed_class=config.digSpeedClass,enchantability=config.enchantability},
 			tool_capabilities={
 				full_punch_interval=1,
 				max_drop_level=config.dropLevel,
@@ -193,7 +219,7 @@ if industrialtest.mclAvailable then
 		minetest.register_tool("industrialtest:"..material.."_shovel",{
 			description=S(materialDisplayName.." Shovel"),
 			inventory_image="industrialtest_mcl_"..material.."_shovel.png",
-			groups={tool=1,shovel=1,dig_speed_class=config.digSpeedClass},
+			groups={tool=1,shovel=1,dig_speed_class=config.digSpeedClass,enchantability=config.enchantability},
 			tool_capabilities={
 				full_punch_interval=1,
 				max_drop_level=config.dropLevel,
@@ -236,7 +262,7 @@ if industrialtest.mclAvailable then
 				return itemstack
 			end,
 			sound={breaks="default_tool_breaks"},
-			_repair_material="industrialtest:"..material,
+			_repair_material="industrialtest:"..materialItem,
 			_mcl_toollike_wield=true,
 			_mcl_diggroups={
 				shovely={speed=config.speed,level=config.level,uses=config.uses}
@@ -245,7 +271,7 @@ if industrialtest.mclAvailable then
 		minetest.register_tool("industrialtest:"..material.."_axe",{
 			description=S(materialDisplayName.." Axe"),
 			inventory_image="industrialtest_mcl_"..material.."_axe.png",
-			groups={tool=1,axe=1,dig_speed_class=config.digSpeedClass},
+			groups={tool=1,axe=1,dig_speed_class=config.digSpeedClass,enchantability=config.enchantability},
 			tool_capabilities={
 				full_punch_interval=1,
 				max_level_drop=config.levelDrop,
@@ -253,7 +279,7 @@ if industrialtest.mclAvailable then
 			},
 			on_place=industrialtest.internal.mclMakeStrippedTrunk,
 			sound={breaks="default_tool_breaks"},
-			_repair_material="industrialtest:"..material,
+			_repair_material="industrialtest:"..materialItem,
 			_mcl_toollike_wield=true,
 			_mcl_diggroups={
 				axey={speed=config.speed,level=config.level,uses=config.uses}
@@ -262,14 +288,14 @@ if industrialtest.mclAvailable then
 		minetest.register_tool("industrialtest:"..material.."_sword",{
 			description=S(materialDisplayName.." Sword"),
 			inventory_image="industrialtest_mcl_"..material.."_sword.png",
-			groups={weapon=1,sword=1,dig_speed_class=config.digSpeedClass},
+			groups={weapon=1,sword=1,dig_speed_class=config.digSpeedClass,enchantability=config.enchantability},
 			tool_capabilities={
 				full_punch_interval=0.625,
 				max_drop_level=config.maxDropLevel,
 				damage_groups={fleshy=config.damage+2},
 			},
 			sound={breaks="default_tool_breaks"},
-			_repair_material="industrialtest:"..material,
+			_repair_material="industrialtest:"..materialItem,
 			_mcl_toollike_wield=true,
 			_mcl_diggroups={
 				swordy={speed=config.speed,level=config.level,uses=config.uses},
@@ -279,7 +305,7 @@ if industrialtest.mclAvailable then
 		minetest.register_tool("industrialtest:"..material.."_hoe",{
 			description=S(materialDisplayName.." Hoe"),
 			inventory_image="industrialtest_mcl_"..material.."_hoe.png",
-			groups={tool=1,hoe=1},
+			groups={tool=1,hoe=1,enchantability=config.enchantability},
 			tool_capabilities={
 				full_punch_interval=1,
 				damage_groups={fleshy=1}
@@ -332,7 +358,7 @@ if industrialtest.mclAvailable then
 					return itemstack
 				end
 			end,
-			_repair_material="industrialtest:"..material,
+			_repair_material="industrialtest:"..materialItem,
 			_mcl_toollike_wield=true,
 			_mcl_diggroups={
 				hoey={speed=config.speed,level=config.level,uses=config.uses}
@@ -343,10 +369,11 @@ if industrialtest.mclAvailable then
 			description=materialDisplayName,
 			durability=config.uses,
 			points=config.armorPoints,
-			craft_material="industrialtest:"..material,
+			craft_material="industrialtest:"..materialItem,
 			cook_material=config.armorCookMaterial,
 			sound_equip=config.armorEquipSound,
 			sound_unequip=config.armorUnequipSound,
 			enchantability=config.enchantability,
 			textures={
 				head="industrialtest_mcl_"..material.."_helmet.png",
 				torso="industrialtest_mcl_"..material.."_chestplate.png",
@@ -358,7 +385,7 @@ if industrialtest.mclAvailable then
 			type="shaped",
 			output="industrialtest:"..material.."_pickaxe",
 			recipe={
-				{"industrialtest:"..material,"industrialtest:"..material,"industrialtest:"..material},
+				{"industrialtest:"..materialItem,"industrialtest:"..materialItem,"industrialtest:"..materialItem},
 				{"","mcl_core:stick",""},
 				{"","mcl_core:stick",""}
 			}
@@ -367,126 +394,54 @@ if industrialtest.mclAvailable then
 			type="shaped",
 			output="industrialtest:"..material.."_shovel",
 			recipe={
-				{"","industrialtest:"..material,""},
+				{"industrialtest:"..materialItem},
-				{"","mcl_core:stick",""},
+				{"mcl_core:stick"},
-				{"","mcl_core:stick",""}
+				{"mcl_core:stick"}
 			}
 		})
 		minetest.register_craft({
 			type="shaped",
 			output="industrialtest:"..material.."_shovel",
 			recipe={
 				{"industrialtest:"..material,"",""},
 				{"mcl_core:stick","",""},
 				{"mcl_core:stick","",""}
 			}
 		})
 		minetest.register_craft({
 			type="shaped",
 			output="industrialtest:"..material.."_shovel",
 			recipe={
 				{"","","industrialtest:"..material},
 				{"","","mcl_core:stick"},
 				{"","","mcl_core:stick"}
 			}
 		})
 		minetest.register_craft({
 			type="shaped",
 			output="industrialtest:"..material.."_axe",
 			recipe={
-				{"industrialtest:"..material,"industrialtest:"..material,""},
+				{"industrialtest:"..materialItem,"industrialtest:"..materialItem},
-				{"industrialtest:"..material,"mcl_core:stick",""},
+				{"industrialtest:"..materialItem,"mcl_core:stick"},
-				{"","mcl_core:stick",""}
+				{"","mcl_core:stick"}
 			}
 		})
 		minetest.register_craft({
 			type="shaped",
 			output="industrialtest:"..material.."_axe",
 			recipe={
-				{"","industrialtest:"..material,"industrialtest:"..material},
+				{"industrialtest:"..materialItem,"industrialtest:"..materialItem},
-				{"","mcl_core:stick","industrialtest:"..material},
+				{"mcl_core:stick","industrialtest:"..materialItem},
-				{"","mcl_core:stick",""}
+				{"mcl_core:stick",""}
 			}
 		})
 		minetest.register_craft({
 			type="shaped",
 			output="industrialtest:"..material.."_axe",
 			recipe={
 				{"industrialtest:"..material,"industrialtest:"..material,""},
 				{"mcl_core:stick","industrialtest:"..material,""},
 				{"mcl_core:stick","",""}
 			}
 		})
 		minetest.register_craft({
 			type="shaped",
 			output="industrialtest:"..material.."_axe",
 			recipe={
 				{"","industrialtest:"..material,"industrialtest:"..material},
 				{"","mcl_core:stick","industrialtest:"..material},
 				{"","","mcl_core:stick"}
 			}
 		})
 		minetest.register_craft({
 			type="shaped",
 			output="industrialtest:"..material.."_sword",
 			recipe={
-				{"industrialtest:"..material,"",""},
+				{"industrialtest:"..materialItem},
-				{"industrialtest:"..material,"",""},
+				{"industrialtest:"..materialItem},
-				{"mcl_core:stick","",""}
+				{"mcl_core:stick"}
 			}
 		})
 		minetest.register_craft({
 			type="shaped",
 			output="industrialtest:"..material.."_sword",
 			recipe={
 				{"","industrialtest:"..material,""},
 				{"","industrialtest:"..material,""},
 				{"","mcl_core:stick",""}
 			}
 		})
 		minetest.register_craft({
 			type="shaped",
 			output="industrialtest:"..material.."_sword",
 			recipe={
 				{"","","industrialtest:"..material},
 				{"","","industrialtest:"..material},
 				{"","","mcl_core:stick"}
 			}
 		})
 		minetest.register_craft({
 			type="shaped",
 			output="industrialtest:"..material.."_hoe",
 			recipe={
-				{"industrialtest:"..material,"industrialtest:"..material,""},
+				{"industrialtest:"..materialItem,"industrialtest:"..materialItem},
-				{"","mcl_core:stick",""},
+				{"","mcl_core:stick"},
-				{"","mcl_core:stick",""}
+				{"","mcl_core:stick"}
 			}
 		})
 		minetest.register_craft({
 			type="shaped",
 			output="industrialtest:"..material.."_hoe",
 			recipe={
-				{"","industrialtest:"..material,"industrialtest:"..material},
+				{"industrialtest:"..materialItem,"industrialtest:"..materialItem},
-				{"","","mcl_core:stick"},
+				{"mcl_core:stick",""},
-				{"","","mcl_core:stick"}
+				{"mcl_core:stick",""}
 			}
 		})
 		minetest.register_craft({
 			type="shaped",
 			output="industrialtest:"..material.."_hoe",
 			recipe={
 				{"","industrialtest:"..material,"industrialtest:"..material},
 				{"","mcl_core:stick",""},
 				{"","mcl_core:stick",""}
 			}
 		})
 		minetest.register_craft({
 			type="shaped",
 			output="industrialtest:"..material.."_hoe",
 			recipe={
 				{"industrialtest:"..material,"industrialtest:"..material,""},
 				{"mcl_core:stick","",""},
 				{"mcl_core:stick","",""}
 			}
 		})
 	end
@@ -497,6 +452,7 @@ if industrialtest.mclAvailable then
 	industrialtest.elementKeys.snowball="mcl_throwing:snowball"
 	industrialtest.elementKeys.string="mcl_mobitems:string"
 	industrialtest.elementKeys.junglePlanks="mcl_core:junglewood"
 	industrialtest.elementKeys.wood="mcl_core:tree"
 	industrialtest.elementKeys.ironIngot="mcl_core:iron_ingot"
 	industrialtest.elementKeys.ironLump="mcl_raw_ores:raw_iron"
 	industrialtest.elementKeys.goldIngot="mcl_core:gold_ingot"
@@ -518,6 +474,7 @@ if industrialtest.mclAvailable then
 	industrialtest.elementKeys.stone="mcl_core:stone"
 	industrialtest.elementKeys.stoneSlab="mcl_stairs:slab_stone"
 	industrialtest.elementKeys.cobble="mcl_core:cobble"
 	industrialtest.elementKeys.mossCobble="mcl_core:mossycobble"
 	industrialtest.elementKeys.sand="mcl_core:sand"
 	industrialtest.elementKeys.gravel="mcl_core:gravel"
 	industrialtest.elementKeys.ice="mcl_core:ice"
@@ -537,12 +494,27 @@ if industrialtest.mclAvailable then
 	industrialtest.elementKeys.stoneWithGold="mcl_core:stone_with_gold"
 	industrialtest.elementKeys.copperBlock="mcl_copper:block"
 	industrialtest.elementKeys.stoneWithCopper="mcl_copper:stone_with_copper"
 	industrialtest.elementKeys.leadLump="industrialtest:raw_lead"
 	industrialtest.elementKeys.ironPickaxe="mcl_tools:pick_iron"
 	industrialtest.elementKeys.ironHelmet="mcl_tools:helmet_iron"
 	industrialtest.elementKeys.ironBoots="mcl_armor:boots_iron"
 	industrialtest.elementKeys.lavaSource="mcl_core:lava_source"
 	industrialtest.elementKeys.waterSource="mcl_core:water_source"
 	industrialtest.elementKeys.sugarCane="mcl_core:reeds"
 	industrialtest.elementKeys.wheat="mcl_farming:wheat_item"
 	industrialtest.elementKeys.dryShrub="mcl_core:deadbush"
 	industrialtest.elementKeys.cactus="mcl_core:cactus"
 	industrialtest.elementKeys.gunpowder="mcl_mobitems:gunpowder"
 	industrialtest.elementKeys.groupSapling="group:sapling"
 	industrialtest.elementKeys.groupLeaves="group:leaves"
 	industrialtest.elementKeys.stickyResin=(industrialtest.mods.mclRubber and "mcl_rubber:rubber_raw" or "industrialtest:sticky_resin")
 	industrialtest.elementKeys.rubber=(industrialtest.mods.mclRubber and "mcl_rubber:rubber" or "industrialtest:rubber")
 	industrialtest.elementKeys.rubberWood=(industrialtest.mods.mclRubber and "mcl_rubber:rubbertree" or "industrialtest:rubber_wood")
 	industrialtest.elementKeys.rubberSapling=(industrialtest.mods.mclRubber and "mcl_rubber:rubbersapling" or "industrialtest:rubber_sapling")
 	industrialtest.elementKeys.treetap=(industrialtest.mods.mclRubber and "mcl_rubber:treetap" or "industrialtest:treetap")
 	-- register required minerals that are not available in MCL
-	industrialtest.registerMetal("tin","Tin",3,3)
+	industrialtest.internal.registerMetal("tin","Tin",3,3)
 	industrialtest.elementKeys.tinIngot="industrialtest:tin_ingot"
 	industrialtest.elementKeys.tinBlock="industrialtest:tin_block"
 	industrialtest.elementKeys.stoneWithTin="industrialtest:stone_with_tin"
@@ -559,7 +531,7 @@ if industrialtest.mclAvailable then
 	})
 	minetest.register_craft({
 		type="shaped",
-		output="industrialcraft:bronze_ingot 9",
+		output="industrialtest:bronze_ingot 9",
 		recipe={
 			{"mcl_copper:copper_ingot","mcl_copper:copper_ingot","mcl_copper:copper_ingot"},
 			{"mcl_copper:copper_ingot","industrialtest:tin_ingot","mcl_copper:copper_ingot"},
@@ -605,7 +577,8 @@ if industrialtest.mclAvailable then
 		},
 		armorCookMaterial="industrialtest:bronze_nugget",
 		armorEquipSound="mcl_armor_equip_iron",
-		armorUnequipSound="mcl_armor_unequip_iron"
+		armorUnequipSound="mcl_armor_unequip_iron",
 		enchantability=15,
 	})
 	--register other blocks that are not availabe in MCL
@@ -627,11 +600,11 @@ if industrialtest.mclAvailable then
 			{"industrialtest:bronze_ingot","industrialtest:bronze_ingot","industrialtest:bronze_ingot"}
 		}
 	})
-	
+
 	minetest.register_ore({
 		ore_type="scatter",
 		ore="industrialtest:stone_with_tin",
-		wherein=stonelike,
+		wherein={"mcl_core:stone","mcl_core:diorite","mcl_core:andesite","mcl_core:granite"},
 		clust_scarcity=10*10*10,
 		clust_num_ores=5,
 		clust_size=3,
@@ -649,11 +622,7 @@ if industrialtest.mclAvailable then
 		y_min=mcl_vars.mg_overworld_min
 	})
 elseif industrialtest.mtgAvailable then
-	industrialtest.internal.explode=function(pos,radius)
+	industrialtest.internal.registerMetal=function(name,displayName,hardness)
 		tnt.boom(pos,{radius=radius})
 	end
 	industrialtest.registerMetal=function(name,displayName,hardness)
 		minetest.register_craftitem("industrialtest:"..name.."_lump",{
 			description=S(displayName.." Lump"),
 			inventory_image="industrialtest_mtg_"..name.."_lump.png"
@@ -728,12 +697,14 @@ elseif industrialtest.mtgAvailable then
 	industrialtest.elementKeys.bucketWithWater="bucket:bucket_water"
 	industrialtest.elementKeys.string="farming:string"
 	industrialtest.elementKeys.junglePlanks="default:junglewood"
 	industrialtest.elementKeys.wood="default:tree"
 	industrialtest.elementKeys.glass="default:glass"
 	industrialtest.elementKeys.powerCarrier="default:mese_crystal_fragment"
 	industrialtest.elementKeys.furnace="default:furnace"
 	industrialtest.elementKeys.stone="default:stone"
 	industrialtest.elementKeys.stoneSlab="stairs:slab_stone"
 	industrialtest.elementKeys.cobble="default:cobble"
 	industrialtest.elementKeys.mossCobble="default:mossycobble"
 	industrialtest.elementKeys.sand="default:sand"
 	industrialtest.elementKeys.gravel="default:gravel"
 	industrialtest.elementKeys.ice="default:ice"
@@ -756,9 +727,24 @@ elseif industrialtest.mtgAvailable then
 	industrialtest.elementKeys.tinBlock="default:tinblock"
 	industrialtest.elementKeys.stoneWithTin="default:stone_with_tin"
 	industrialtest.elementKeys.bronzeBlock="default:bronzeblock"
 	industrialtest.elementKeys.leadLump="industrialtest:lead_lump"
 	industrialtest.elementKeys.ironPickaxe="default:pick_steel"
 	industrialtest.elementKeys.ironHelmet="3d_armor:helmet_steel"
 	industrialtest.elementKeys.ironBoots="3d_armor:boots_steel"
 	industrialtest.elementKeys.lavaSource="default:lava_source"
 	industrialtest.elementKeys.waterSource="default:water_source"
 	industrialtest.elementKeys.sugarCane="default:papyrus"
 	industrialtest.elementKeys.wheat="farming:wheat"
 	industrialtest.elementKeys.dryShrub="default:dry_shrub"
 	industrialtest.elementKeys.cactus="default:cactus"
 	industrialtest.elementKeys.gunpowder="tnt:gunpowder"
 	industrialtest.elementKeys.groupSapling="group:sapling"
 	industrialtest.elementKeys.groupLeaves="group:leaves"
 	industrialtest.elementKeys.stickyResin="industrialtest:sticky_resin"
 	industrialtest.elementKeys.rubber="industrialtest:rubber"
 	industrialtest.elementKeys.rubberWood="industrialtest:rubber_wood"
 	industrialtest.elementKeys.rubberSapling="industrialtest:rubber_sapling"
 	industrialtest.elementKeys.treetap="industrialtest:treetap"
 else
 	error("No compatible games found!")
 end
--- a/craftitems.lua
+++ b/craftitems.lua
@@ -15,6 +15,31 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
 local colors={
 	bronze="#be4325ff",
 	clay="#707070ff",
 	coal="#262523ff",
 	copper="#bf644aff",
 	diamond="#77cefbff",
 	gold="#eac162ff",
 	iron="#afaca5ff",
 	lapis_lazuli="#3a4cceff",
 	lead="#6d6393ff",
 	mese="#909000ff",
 	obsidian="#292843ff",
 	refined_iron="#94bab9ff",
 	sulfur="#b88805ff",
 	tin="#ebd182ff",
 	uranium="#3b8c09ff",
 	-- fluid colors
 	lava="#ff5712ff",
 	water="#277bbcff",
 	river_water="#0ebfc2ff",
 	biomass="#2a8626ff",
 	biofuel="#4eba49ff",
 	coalfuel="#462228ff",
 	coolant="#188676ff"
 }
 -- Power storage items
 minetest.register_tool("industrialtest:re_battery",{
@@ -95,6 +120,11 @@ minetest.register_craft({
 	output="industrialtest:refined_iron_ingot",
 	recipe=industrialtest.elementKeys.ironIngot
 })
 minetest.register_craft({
 	type="cooking",
 	output="industrialtest:refined_iron_ingot",
 	recipe="industrialtest:refined_iron_dust"
 })
 minetest.register_craft({
 	type="shapeless",
 	output="industrialtest:refined_iron_ingot 8",
@@ -117,31 +147,33 @@ minetest.register_craft({
 	}
 })
-minetest.register_craftitem("industrialtest:sticky_resin",{
+if not industrialtest.mods.mclRubber then
-	description=S("Sticky Resin"),
+	minetest.register_craftitem("industrialtest:sticky_resin",{
-	inventory_image="industrialtest_sticky_resin.png"
+		description=S("Sticky Resin"),
-})
+		inventory_image="industrialtest_sticky_resin.png"
 	})
-minetest.register_craftitem("industrialtest:rubber",{
+	minetest.register_craftitem("industrialtest:rubber",{
-	description=S("Rubber"),
+		description=S("Rubber"),
-	inventory_image="industrialtest_rubber.png"
+		inventory_image="industrialtest_rubber.png"
-})
+	})
-minetest.register_craft({
+	minetest.register_craft({
-	type="cooking",
+		type="cooking",
-	output="industrialtest:rubber",
+		output="industrialtest:rubber",
-	recipe="industrialtest:sticky_resin"
+		recipe="industrialtest:sticky_resin"
 	})
 end
 industrialtest.api.registerExtractorRecipe({
 	output=industrialtest.elementKeys.rubber,
 	recipe=industrialtest.elementKeys.rubberWood
 })
 industrialtest.api.registerExtractorRecipe({
-	output="industrialtest:rubber",
+	output=industrialtest.elementKeys.rubber,
-	recipe="industrialtest:rubber_wood"
+	recipe=industrialtest.elementKeys.rubberSapling
 })
 industrialtest.api.registerExtractorRecipe({
-	output="industrialtest:rubber",
+	output=industrialtest.elementKeys.rubber.." 3",
-	recipe="industrialtest:rubber_sapling"
+	recipe=industrialtest.elementKeys.stickyResin
 })
 industrialtest.api.registerExtractorRecipe({
 	output="industrialtest:rubber 3",
 	recipe="industrialtest:sticky_resin"
 })
 minetest.register_craftitem("industrialtest:raw_carbon_fibre",{
@@ -190,13 +222,13 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("coal","Coal",resources,"#101010ff",true)
+industrialtest.api.registerResourceDust("coal","Coal",resources,colors.coal,true)
 industrialtest.api.registerResourceDust("clay","Clay",{
 	{
 		resource=industrialtest.elementKeys.clayBlock,
 		count=2
 	}
-},"#9090a0ff",true)
+},colors.clay,true)
 resources={
 	{
 		resource=industrialtest.elementKeys.diamondBlock,
@@ -214,7 +246,7 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("diamond","Diamond",resources,"#90e2c9ff",true)
+industrialtest.api.registerResourceDust("diamond","Diamond",resources,colors.diamond,true)
 minetest.register_craft({
 	type="cooking",
 	output=industrialtest.elementKeys.diamond,
@@ -241,7 +273,7 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("iron","Iron",resources,"#b5b5b5ff",true)
+industrialtest.api.registerResourceDust("iron","Iron",resources,colors.iron,true)
 minetest.register_craft({
 	type="cooking",
 	output=industrialtest.elementKeys.ironIngot,
@@ -262,9 +294,9 @@ if industrialtest.mclAvailable then
 			count=9
 		},
 		{resource="mcl_core:lapis_lazuli"}
-	},"#292d76ff",true)
+	},colors.lapis_lazuli,true)
 end
-industrialtest.api.registerResourceDust("obsidian","Obsidian",{{resource=industrialtest.elementKeys.obsidian}},"#292843ff",true)
+industrialtest.api.registerResourceDust("obsidian","Obsidian",{{resource=industrialtest.elementKeys.obsidian}},colors.obsidian,true)
 resources={
 	{
 		resource=industrialtest.elementKeys.goldBlock,
@@ -286,7 +318,7 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("gold","Gold",resources,"#e4e526ff",true)
+industrialtest.api.registerResourceDust("gold","Gold",resources,colors.gold,true)
 minetest.register_craft({
 	type="cooking",
 	output=industrialtest.elementKeys.goldIngot,
@@ -313,7 +345,7 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("copper","Copper",resources,"#a45e25ff",true)
+industrialtest.api.registerResourceDust("copper","Copper",resources,colors.copper,true)
 minetest.register_craft({
 	type="cooking",
 	output=industrialtest.elementKeys.copperIngot,
@@ -340,7 +372,7 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("tin","Tin",resources,"#f1f1f1ff",true)
+industrialtest.api.registerResourceDust("tin","Tin",resources,colors.tin,true)
 minetest.register_craft({
 	type="cooking",
 	output=industrialtest.elementKeys.tinIngot,
@@ -367,7 +399,7 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("uranium","Uranium",resources,"#3b8c09ff",true)
+industrialtest.api.registerResourceDust("uranium","Uranium",resources,colors.uranium,true)
 minetest.register_craft({
 	type="cooking",
 	output="industrialtest:uranium_ingot",
@@ -384,7 +416,7 @@ if industrialtest.mtgAvailable then
 			count=2
 		},
 		{resource="default:mese_crystal"}
-	},"#909000ff",true)
+	},colors.mese,true)
 	minetest.register_craft({
 		type="cooking",
 		output="default:mese_crystal",
@@ -397,7 +429,7 @@ industrialtest.api.registerResourceDust("bronze","Bronze",{
 		count=9
 	},
 	{resource=industrialtest.elementKeys.bronzeIngot}
-},"#e48e88ff",true)
+},colors.bronze,true)
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:bronze_dust 9",
@@ -412,9 +444,104 @@ minetest.register_craft({
 	output=industrialtest.elementKeys.bronzeIngot,
 	recipe="industrialtest:bronze_dust"
 })
-industrialtest.api.registerResourceDust("sulfur","Sulfur",{},"#e3ff33ff",false)
+industrialtest.api.registerRotaryMaceratorModifier({
-industrialtest.api.registerResourceDust("lead","Lead",{},"#eafef8ff",false)
+	name=industrialtest.elementKeys.copperLump,
-- TODO: Add lead ore
+	modifier=industrialtest.elementKeys.tinLump,
 	output="industrialtest:bronze_dust 2",
 	uses=4
 })
 industrialtest.api.registerRotaryMaceratorModifier({
 	name=industrialtest.elementKeys.copperIngot,
 	modifier=industrialtest.elementKeys.tinIngot,
 	output="industrialtest:bronze_dust",
 	uses=4
 })
 industrialtest.api.registerResourceDust("sulfur","Sulfur",{},colors.sulfur,false)
 industrialtest.api.registerExtractorRecipe({
 	output="industrialtest:sulfur_dust",
 	recipe=industrialtest.elementKeys.gunpowder
 })
 industrialtest.api.registerResourceDust("lead","Lead",{
 	{
 		resource="industrialtest:lead_block",
 		count=9
 	},
 	{
 		resource="industrialtest:lead_ore",
 		count=2
 	},
 	{
 		resource=industrialtest.elementKeys.leadLump,
 		count=2
 	},
 	{resource="industrialtest:lead_ingot"}
 },colors.lead,true)
 minetest.register_craft({
 	type="cooking",
 	output="industrialtest:lead_ingot",
 	recipe="industrialtest:lead_dust"
 })
 industrialtest.api.registerResourceDust("refined_iron","Refined Iron",{
 	{
 		resource="industrialtest:refined_iron_ingot",
 		count=1
 	}
 },colors.refined_iron,true)
 industrialtest.api.registerRotaryMaceratorModifier({
 	name=industrialtest.elementKeys.ironLump,
 	modifier=industrialtest.elementKeys.coal,
 	output="industrialtest:refined_iron_dust 2",
 	uses=industrialtest.stackMax
 })
 minetest.register_craftitem("industrialtest:hydrated_coal_dust",{
 	description=S("Hydrated Coal Dust"),
 	inventory_image="industrialtest_hydrated_coal_dust.png"
 })
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:hydrated_coal_dust 8",
 	recipe={
 		{"industrialtest:coal_dust","industrialtest:coal_dust","industrialtest:coal_dust"},
 		{"industrialtest:coal_dust",industrialtest.elementKeys.bucketWithWater,"industrialtest:coal_dust"},
 		{"industrialtest:coal_dust","industrialtest:coal_dust","industrialtest:coal_dust"}
 	},
 	replacements={
 		{
 			industrialtest.elementKeys.bucketWithWater,
 			industrialtest.elementKeys.bucket
 		}
 	}
 })
 minetest.register_craft({
 	type="shapeless",
 	output="industrialtest:hydrated_coal_dust",
 	recipe={
 		"industrialtest:coal_dust",
 		industrialtest.elementKeys.bucketWithWater
 	},
 	replacements={
 		{
 			industrialtest.elementKeys.bucketWithWater,
 			industrialtest.elementKeys.bucket
 		}
 	}
 })
 industrialtest.api.registerRotaryMaceratorModifier({
 	name=industrialtest.elementKeys.coal,
 	modifier="industrialtest:water_cell",
 	output="industrialtest:hydrated_coal_dust",
 	uses=8
 })
 minetest.register_craftitem("industrialtest:hydrated_coal",{
 	description=S("Hydrated Coal"),
 	inventory_image="industrialtest_hydrated_coal.png"
 })
 industrialtest.api.registerCompressorRecipe({
 	output="industrialtest:hydrated_coal",
 	recipe="industrialtest:hydrated_coal_dust"
 })
 -- Plates
 industrialtest.api.registerPlate("bronze_plate",S("Bronze Plate"),{
@@ -422,14 +549,14 @@ industrialtest.api.registerPlate("bronze_plate",S("Bronze Plate"),{
 		resource=industrialtest.elementKeys.bronzeIngot,
 		count=1
 	}
-},"#e48e88ff",true)
+},colors.bronze,true)
 industrialtest.api.registerPlate("copper_plate",S("Copper Plate"),{
 	{
 		resource=industrialtest.elementKeys.copperIngot,
 		count=1
 	}
-},"#f48e44ff",true)
+},colors.copper,true)
 industrialtest.api.registerPlate("advanced_alloy",S("Advanced Alloy"),{
 	{
@@ -445,6 +572,31 @@ industrialtest.api.registerPlate("carbon_plate",S("Carbon Plate"),{
 	}
 },"#272725ff",true)
 industrialtest.api.registerPlate("tin_plate",S("Tin Plate"),{
 	{
 		resource=industrialtest.elementKeys.tinIngot,
 		count=1
 	}
 },colors.tin,true)
 industrialtest.api.registerPlate("lead_plate",S("Lead Plate"),{
 	{
 		resource="industrialtest:lead_ingot",
 		count=1
 	}
 },colors.lead,true)
 industrialtest.api.registerPlate("iridium_plate",S("Iridium Plate"),{},false,"#ffffffff")
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:iridium_plate",
 	recipe={
 		{"industrialtest:iridium_ingot","industrialtest:advanced_alloy","industrialtest:iridium_ingot"},
 		{"industrialtest:advanced_alloy",industrialtest.elementKeys.diamond,"industrialtest:advanced_alloy"},
 		{"industrialtest:iridium_ingot","industrialtest:advanced_alloy","industrialtest:iridium_ingot"}
 	}
 })
 -- Cells
 minetest.register_craftitem("industrialtest:empty_cell",{
 	description=S("Empty Cell"),
@@ -482,12 +634,12 @@ minetest.register_craft({
 		{"",industrialtest.elementKeys.tinIngot,""}
 	}
 })
-industrialtest.api.registerStorageCell("water","Water",industrialtest.elementKeys.waterSource)
+industrialtest.api.registerStorageCell("water","Water",industrialtest.elementKeys.waterSource,nil,colors.water)
 if industrialtest.mtgAvailable then
-	industrialtest.api.registerStorageCell("river_water","River Water","default:river_water_source")
+	industrialtest.api.registerStorageCell("river_water","River Water","default:river_water_source",nil,colors.river_water)
 end
-industrialtest.api.registerStorageCell("lava","Lava",industrialtest.elementKeys.lavaSource)
+industrialtest.api.registerStorageCell("lava","Lava",industrialtest.elementKeys.lavaSource,nil,colors.lava)
 minetest.register_tool("industrialtest:uranium_cell",{
 	description=S("Uranium Cell"),
@@ -495,7 +647,9 @@ minetest.register_tool("industrialtest:uranium_cell",{
 		_industrialtest_placedInNuclearReactor=1,
 		_industrialtest_nuclearReactorFuel=1
 	},
-	inventory_image="industrialtest_uranium_cell.png",
+	inventory_image="industrialtest_cell_fluid.png",
 	inventory_overlay="industrialtest_cell_casing.png",
 	color=colors.uranium,
 })
 minetest.register_craft({
 	type="shapeless",
@@ -512,7 +666,9 @@ minetest.register_tool("industrialtest:coolant_cell",{
 		_industrialtest_placedInNuclearReactor=1,
 		_industrialtest_nuclearReactorCoolant=1
 	},
-	inventory_image="industrialtest_coolant_cell.png",
+	inventory_image="industrialtest_cell_fluid.png",
 	inventory_overlay="industrialtest_cell_casing.png",
 	color=colors.coolant,
 })
 minetest.register_craft({
 	type="shaped",
@@ -535,6 +691,70 @@ if industrialtest.mtgAvailable then
 	})
 end
 minetest.register_craftitem("industrialtest:bio_cell",{
 	description=S("Bio Cell"),
 	inventory_image="industrialtest_cell_fluid.png",
 	inventory_overlay="industrialtest_cell_casing.png",
 	color=colors.biomass,
 })
 minetest.register_craft({
 	type="shapeless",
 	output="industrialtest:bio_cell",
 	recipe={
 		"industrialtest:empty_cell",
 		"industrialtest:compressed_plantball"
 	}
 })
 minetest.register_craftitem("industrialtest:biofuel_cell",{
 	description=S("Biofuel Cell"),
 	inventory_image="industrialtest_cell_fluid.png",
 	inventory_overlay="industrialtest_cell_casing.png",
 	color=colors.biofuel,
 	groups={
 		_industrialtest_fuel=1
 	},
 	_industrialtest_fuelAmount=500,
 	_industrialtest_emptyVariant="industrialtest:empty_cell"
 })
 industrialtest.api.registerExtractorRecipe({
 	output="industrialtest:biofuel_cell",
 	recipe="industrialtest:bio_cell",
 	time=4
 })
 minetest.register_craftitem("industrialtest:hydrated_coal_cell",{
 	description=S("Hydrated Coal Cell"),
 	inventory_image="industrialtest_cell_fluid.png",
 	inventory_overlay="industrialtest_cell_casing.png",
 	color=colors.coal,
 })
 minetest.register_craft({
 	type="shapeless",
 	output="industrialtest:hydrated_coal_cell",
 	recipe={
 		"industrialtest:empty_cell",
 		"industrialtest:hydrated_coal"
 	}
 })
 minetest.register_craftitem("industrialtest:coalfuel_cell",{
 	description=S("Coalfuel Cell"),
 	inventory_image="industrialtest_cell_fluid.png",
 	inventory_overlay="industrialtest_cell_casing.png",
 	color=colors.coalfuel,
 	groups={
 		_industrialtest_fuel=1
 	},
 	_industrialtest_fuelAmount=1000,
 	_industrialtest_emptyVariant="industrialtest:empty_cell"
 })
 industrialtest.api.registerExtractorRecipe({
 	output="industrialtest:coal_cell",
 	recipe="industrialtest:hydrated_coal_cell",
 	time=4
 })
 -- Other items
 minetest.register_craftitem("industrialtest:electronic_circuit",{
 	description=S("Electronic Circuit"),
@@ -583,17 +803,91 @@ minetest.register_craftitem("industrialtest:uu_matter",{
 	inventory_image="industrialtest_uu_matter.png"
 })
-- Item callbacks
+minetest.register_craftitem("industrialtest:plantball",{
-minetest.register_on_player_inventory_action(function(player,action,inventory,info)
+	description=S("Plantball"),
-	if action=="put" then
+	inventory_image="industrialtest_plantball.png"
-		if industrialtest.api.preparePowerStorageItem(info.stack) or industrialtest.api.prepareToolItem(info.stack) then
+})
-			inventory:set_stack(info.listname,info.index,info.stack)
+minetest.register_craft({
-		end
+	type="shaped",
-	end
+	output="industrialtest:plantball 2",
-end)
+	recipe={
-minetest.register_on_craft(function(itemstack)
+		{industrialtest.elementKeys.groupSapling,industrialtest.elementKeys.groupSapling,industrialtest.elementKeys.groupSapling},
-	if industrialtest.api.preparePowerStorageItem(itemstack) then
+		{industrialtest.elementKeys.groupSapling,"",industrialtest.elementKeys.groupSapling},
-		return
+		{industrialtest.elementKeys.groupSapling,industrialtest.elementKeys.groupSapling,industrialtest.elementKeys.groupSapling}
-	end
+	}
-	industrialtest.api.prepareToolItem(itemstack)
+})
-end)
+minetest.register_craft({
 	type="shaped",
 	output="industrialtest:plantball",
 	recipe={
 		{industrialtest.elementKeys.groupLeaves,industrialtest.elementKeys.groupLeaves,industrialtest.elementKeys.groupLeaves},
 		{industrialtest.elementKeys.groupLeaves,"",industrialtest.elementKeys.groupLeaves},
 		{industrialtest.elementKeys.groupLeaves,industrialtest.elementKeys.groupLeaves,industrialtest.elementKeys.groupLeaves}
 	}
 })
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:plantball",
 	recipe={
 		{industrialtest.elementKeys.sugarCane,industrialtest.elementKeys.sugarCane,industrialtest.elementKeys.sugarCane},
 		{industrialtest.elementKeys.sugarCane,"",industrialtest.elementKeys.sugarCane},
 		{industrialtest.elementKeys.sugarCane,industrialtest.elementKeys.sugarCane,industrialtest.elementKeys.sugarCane}
 	}
 })
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:plantball",
 	recipe={
 		{industrialtest.elementKeys.wheat,industrialtest.elementKeys.wheat,industrialtest.elementKeys.wheat},
 		{industrialtest.elementKeys.wheat,"",industrialtest.elementKeys.wheat},
 		{industrialtest.elementKeys.wheat,industrialtest.elementKeys.wheat,industrialtest.elementKeys.wheat}
 	}
 })
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:plantball",
 	recipe={
 		{industrialtest.elementKeys.dryShrub,industrialtest.elementKeys.dryShrub,industrialtest.elementKeys.dryShrub},
 		{industrialtest.elementKeys.dryShrub,"",industrialtest.elementKeys.dryShrub},
 		{industrialtest.elementKeys.dryShrub,industrialtest.elementKeys.dryShrub,industrialtest.elementKeys.dryShrub}
 	}
 })
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:plantball",
 	recipe={
 		{industrialtest.elementKeys.cactus,industrialtest.elementKeys.cactus,industrialtest.elementKeys.cactus},
 		{industrialtest.elementKeys.cactus,"",industrialtest.elementKeys.cactus},
 		{industrialtest.elementKeys.cactus,industrialtest.elementKeys.cactus,industrialtest.elementKeys.cactus}
 	}
 })
 minetest.register_craftitem("industrialtest:compressed_plantball",{
 	description=S("Compressed Plantball"),
 	inventory_image="industrialtest_compressed_plantball.png"
 })
 industrialtest.api.registerCompressorRecipe({
 	output="industrialtest:compressed_plantball",
 	recipe="industrialtest:plantball",
 	time=5
 })
 minetest.register_tool("industrialtest:fuel_can",{
 	description=S("Fuel Can"),
 	inventory_image="industrialtest_fuel_can.png",
 	groups={
 		_industrialtest_fueled=1,
 		_industrialtest_fuel=1,
 		_industrialtest_fluidStorage=1
 	},
 	_industrialtest_fluidCapacity=10000
 })
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:fuel_can",
 	recipe={
 		{"","industrialtest:tin_plate","industrialtest:tin_plate"},
 		{"industrialtest:tin_plate","","industrialtest:tin_plate"},
 		{"industrialtest:tin_plate","industrialtest:tin_plate","industrialtest:tin_plate"}
 	}
 })
--- a/init.lua
+++ b/init.lua
@@ -14,8 +14,7 @@
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-MODNAME="industrialtest"
+local modpath=minetest.get_modpath("industrialtest")
 local modpath=minetest.get_modpath(MODNAME)
 -- table with global functions, variables etc
 industrialtest={}
@@ -29,27 +28,65 @@ industrialtest.random=PseudoRandom(os.time())
 -- load other lua files
 dofile(modpath.."/compatibility.lua")
 dofile(modpath.."/api.lua")
 dofile(modpath.."/minerals.lua")
-dofile(modpath.."/machines/common.lua")
+dofile(modpath.."/api/common.lua")
 dofile(modpath.."/api/fluid.lua")
 dofile(modpath.."/api/network.lua")
 dofile(modpath.."/api/power.lua")
 dofile(modpath.."/api/registration.lua")
 dofile(modpath.."/api/side.lua")
 dofile(modpath.."/machines/machine.lua")
 dofile(modpath.."/machines/activated_machine.lua")
 dofile(modpath.."/machines/electric_machine.lua")
 dofile(modpath.."/machines/activated_electric_machine.lua")
 dofile(modpath.."/machines/simple_electric_item_processor.lua")
 dofile(modpath.."/machines/canning_machine.lua")
 dofile(modpath.."/machines/chargepad.lua")
 dofile(modpath.."/machines/compressor.lua")
 dofile(modpath.."/machines/cable_former.lua")
 dofile(modpath.."/machines/electric_furnace.lua")
 dofile(modpath.."/machines/extractor.lua")
 dofile(modpath.."/machines/fluid_generator.lua")
 dofile(modpath.."/machines/generator.lua")
 dofile(modpath.."/machines/induction_furnace.lua")
 dofile(modpath.."/machines/iron_furnace.lua")
 dofile(modpath.."/machines/macerator.lua")
 dofile(modpath.."/machines/mass_fabricator.lua")
 dofile(modpath.."/machines/nuclear_reactor.lua")
 dofile(modpath.."/machines/power_storage.lua")
 dofile(modpath.."/machines/recycler.lua")
 dofile(modpath.."/machines/rotary_macerator.lua")
 dofile(modpath.."/machines/tool_workshop.lua")
 dofile(modpath.."/machines/transformer.lua")
 dofile(modpath.."/machines/solar_panel_generator.lua")
 dofile(modpath.."/machines/wind_mill.lua")
 dofile(modpath.."/tools/common.lua")
 dofile(modpath.."/tools/item.lua")
 dofile(modpath.."/tools/electric_item.lua")
 dofile(modpath.."/tools/electric_armor.lua")
 dofile(modpath.."/tools/fluid_container_item.lua")
 dofile(modpath.."/tools/tool.lua")
 dofile(modpath.."/tools/gear_tool.lua")
 dofile(modpath.."/tools/electric_tool.lua")
 dofile(modpath.."/tools/activated_electric_tool.lua")
 dofile(modpath.."/tools/electric_gear_tool.lua")
 dofile(modpath.."/tools/batpack.lua")
 dofile(modpath.."/tools/electric_chainsaw.lua")
 dofile(modpath.."/tools/electric_drill.lua")
 dofile(modpath.."/tools/electric_hoe.lua")
 dofile(modpath.."/tools/electric_saber.lua")
 dofile(modpath.."/tools/jetpack.lua")
 dofile(modpath.."/tools/mining_laser.lua")
 dofile(modpath.."/tools/nano_suit.lua")
 dofile(modpath.."/tools/solar_helmet.lua")
 dofile(modpath.."/tools/static_boots.lua")
 dofile(modpath.."/tools/treetap.lua")
 dofile(modpath.."/tools/quantum_suit.lua")
 dofile(modpath.."/tools/wrench.lua")
 dofile(modpath.."/upgrades.lua")
 dofile(modpath.."/craftitems.lua")
 dofile(modpath.."/nodes.lua")
@@ -58,5 +95,16 @@ if industrialtest.developerMode then
 end
 dofile(modpath.."/cables.lua")
 dofile(modpath.."/mapgen.lua")
-dofile(modpath.."/tools.lua")
+dofile(modpath.."/uu_matter_crafts.lua")
 dofile(modpath.."/crafts.lua")
 -- compatibility with other mods
 if industrialtest.mods.pipeworks then
 	dofile(modpath.."/compat/pipeworks.lua")
 end
 if industrialtest.mods.logistica then
 	dofile(modpath.."/compat/logistica.lua")
 end
 if industrialtest.mods.mesecons then
 	dofile(modpath.."/compat/mesecons.lua")
 end
--- a/machines/activated_electric_machine.lua
+++ b/machines/activated_electric_machine.lua
@@ -0,0 +1,44 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 industrialtest.ActivatedElectricMachine=table.copy(industrialtest.ElectricMachine)
 -- Forward methods from ActivatedMachine
 industrialtest.internal.unpackTableInto(industrialtest.ActivatedElectricMachine,{
 	canUpdate=industrialtest.ActivatedMachine.canUpdate,
 	register=industrialtest.ActivatedMachine.register,
 	createDefinitionTable=industrialtest.ActivatedMachine.createDefinitionTable,
 	createActiveDefinitionTable=industrialtest.ActivatedMachine.createActiveDefinitionTable,
 	activate=industrialtest.ActivatedMachine.activate,
 	deactivate=industrialtest.ActivatedMachine.deactivate,
 	shouldActivate=industrialtest.ActivatedMachine.shouldActivate,
 	shouldDeactivate=industrialtest.ActivatedMachine.shouldDeactivate,
 	afterActivation=industrialtest.ActivatedMachine.afterActivation,
 	afterDeactivation=industrialtest.ActivatedMachine.afterDeactivation
 })
 function industrialtest.ActivatedElectricMachine.onTimer(self,pos,elapsed)
 	local result=self:powerExchange(pos)
 	local result2=industrialtest.ActivatedMachine.onTimer(self,pos,elapsed)
 	return result or result2
 end
 function industrialtest.ActivatedElectricMachine.activeOnTimer(self,pos,elapsed)
 	local result=self:powerExchange(pos)
 	local result2=industrialtest.ActivatedMachine.activeOnTimer(self,pos,elapsed)
 	return result or result2
 end
--- a/machines/activated_machine.lua
+++ b/machines/activated_machine.lua
@@ -0,0 +1,114 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 industrialtest.ActivatedMachine=table.copy(industrialtest.Machine)
 function industrialtest.ActivatedMachine.canUpdate(self,pos)
 	return self:shouldActivate(pos)
 end
 function industrialtest.ActivatedMachine.onTimer(self,pos,elapsed)
 	local result=industrialtest.Machine.onTimer(self,pos,elapsed)
 	if self:shouldActivate(pos) then
 		self:activate(pos)
 		return false
 	end
 	return result
 end
 function industrialtest.ActivatedMachine.register(self)
 	industrialtest.Machine.register(self)
 	local def=self:createActiveDefinitionTable()
 	minetest.register_node(self.name.."_active",def)
 end
 function industrialtest.ActivatedMachine.createActiveDefinitionTable(self)
 	local def=self:createDefinitionTable()
 	def.description=nil
 	def.drop=def.drop or self.name
 	if self.active then
 		def.tiles=self.active.tiles or def.tiles
 		def.light_source=self.active.lightSource
 	end
 	def.on_timer=function(pos,elapsed)
 		return self:activeOnTimer(pos,elapsed)
 	end
 	if industrialtest.mclAvailable then
 		def.groups.not_in_creative_inventory=1
 		def._doc_items_create_entry=false
 	end
 	return def
 end
 function industrialtest.ActivatedMachine.activate(self,pos)
 	minetest.swap_node(pos,{
 		name=self.name.."_active",
 		param2=minetest.get_node(pos).param2
 	})
 	self:afterActivation(pos)
 	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 end
 function industrialtest.ActivatedMachine.deactivate(self,pos)
 	minetest.swap_node(pos,{
 		name=self.name,
 		param2=minetest.get_node(pos).param2
 	})
 	self:afterDeactivation(pos)
 	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 end
 function industrialtest.ActivatedMachine.shouldActivate(self,pos)
 	return false
 end
 function industrialtest.ActivatedMachine.shouldDeactivate(self,pos)
 	return false
 end
 function industrialtest.ActivatedMachine.afterActivation(self,pos)
 end
 function industrialtest.ActivatedMachine.afterDeactivation(self,pos)
 end
 function industrialtest.ActivatedMachine.activeOnTimer(self,pos,elapsed)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local shouldUpdateFormspec=false
 	if self:shouldDeactivate(pos) then
 		self:deactivate(pos)
 		return false
 	end
 	if self.activeUpdate then
 		shouldUpdateFormspec=self:activeUpdate(pos,elapsed,meta,inv)
 	end
 	if shouldUpdateFormspec then
 		self:updateFormspec(pos)
 	end
 	return true
 end
--- a/machines/cable_former.lua
+++ b/machines/cable_former.lua
@@ -15,18 +15,55 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-
+industrialtest.CableFormer=table.copy(industrialtest.SimpleElectricItemProcessor)
-industrialtest.internal.registerSimpleElectricItemProcessor({
+industrialtest.internal.unpackTableInto(industrialtest.CableFormer,{
-	name="cable_former",
+	name="industrialtest:cable_former",
-	displayName=S("Cable Former"),
+	description=S("Cable Former"),
-	customFrontTexture=true,
+	tiles={
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_cable_former_front.png"
 	},
 	requiresWrench=true,
 	active={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_cable_former_front_active.png"
 		}
 	},
 	capacity=1400,
 	flow=industrialtest.api.lvPowerFlow,
 	opPower=80,
 	method="industrialtest.cable_forming",
 	efficiency=1
 })
 function industrialtest.CableFormer.getCraftResult(self,itemstack)
 	local output=industrialtest.api.getCableFormerRecipeResult(itemstack:get_name())
 	if not output then
 		return {
 			item=ItemStack(),
 			time=0,
 			src=itemstack
 		}
 	end
 	local srcAfter=ItemStack(itemstack:get_name())
 	srcAfter:set_count(itemstack:get_count()-1)
 	return {
 		item=ItemStack(output.output),
 		time=output.time,
 		src=srcAfter
 	}
 end
 industrialtest.CableFormer:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:cable_former",
--- a/machines/canning_machine.lua
+++ b/machines/canning_machine.lua
@@ -0,0 +1,251 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
 industrialtest.CanningMachine=table.copy(industrialtest.ActivatedElectricMachine)
 industrialtest.internal.unpackTableInto(industrialtest.CanningMachine,{
 	name="industrialtest:canning_machine",
 	description=S("Canning Machine"),
 	tiles={
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_canning_machine_front.png"
 	},
 	sounds="metal",
 	facedir=true,
 	storageLists={
 		"src",
 		"dst",
 		"leftover",
 		"upgrades",
 		"powerStorage"
 	},
 	powerLists={
 		{
 			list="powerStorage",
 			direction="i"
 		}
 	},
 	active={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_canning_machine_front_active.png"
 		}
 	},
 	capacity=industrialtest.api.lvPowerFlow*2,
 	flow=industrialtest.api.lvPowerFlow,
 	ioConfig="iiiiii",
 	requiresWrench=true,
 	hasPowerInput=true,
 	_opPower=200,
 	_canningTime=5
 })
 function industrialtest.CanningMachine.onConstruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	inv:set_size("src",1)
 	inv:set_size("dst",1)
 	inv:set_size("leftover",1)
 	inv:set_size("powerStorage",1)
 	inv:set_size("upgrades",4)
 	meta:set_float("srcTime",0)
 	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
 end
 function industrialtest.CanningMachine.getFormspec(self,pos)
 	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
 	local srcPercent=meta:get_float("srcTime")/self._canningTime*100
 	local formspec={
 		"list[context;src;3.4,1.8;1,1]",
 		industrialtest.internal.getItemSlotBg(3.4,1.8,1,1),
 		(powerPercent>0 and "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
 		 or "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
 		"list[context;powerStorage;3.4,3.9;1,1]",
 		industrialtest.internal.getItemSlotBg(3.4,3.9,1,1),
 		(srcPercent>0 and "image[4.9,1.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
 		 or "image[4.9,1.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
 		"list[context;dst;6.4,1.8;1,1]",
 		industrialtest.internal.getItemSlotBg(6.4,1.8,1,1),
 		"list[context;leftover;6.4,2.8;1,1]",
 		industrialtest.internal.getItemSlotBg(6.4,2.8,1,1),
 		"list[context;upgrades;9,0.9;1,4]",
 		industrialtest.internal.getItemSlotBg(9,0.9,1,4),
 		"listring[context;src]",
 		"listring[context;dst]"
 	}
 	return parentFormspec..table.concat(formspec,"")
 end
 function industrialtest.CanningMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	if toList=="src" then
 		local inv=minetest.get_meta(pos):get_inventory()
 		local itemstack=inv:get_stack(fromList,fromIndex)
 		local def=itemstack:get_definition()
 		return (def.groups and def.groups._industrialtest_fuel) and count or 0
 	end
 	if toList=="dst" then
 		local inv=minetest.get_meta(pos):get_inventory()
 		local itemstack=inv:get_stack(fromList,fromIndex)
 		local def=itemstack:get_definition()
 		return (def.groups and def.groups._industrialtest_fueled) and count or 0
 	end
 	if toList=="leftover" then
 		return 0
 	end
 	return math.min(count,industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count))
 end
 function industrialtest.CanningMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
 	if listname=="src" then
 		local def=stack:get_definition()
 		return (def.groups and def.groups._industrialtest_fuel) and stack:get_count() or 0
 	end
 	if listname=="dst" then
 		local def=stack:get_definition()
 		return (def.groups and def.groups._industrialtest_fueled) and stack:get_count() or 0
 	end
 	if listname=="leftover" then
 		return 0
 	end
 	return math.min(stack:get_count(),industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player))
 end
 function industrialtest.CanningMachine.allowMetadataInventoryTake(self,pos,listname,index,stack,player)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local fuelSlot=inv:get_stack("src",1)
 	local targetSlot=inv:get_stack("dst",1)
 	if ((listname=="src" and stack:get_count()==fuelSlot:get_count()) or (listname=="dst" and stack:get_count()==targetSlot:get_count())) and meta:get_float("srcTime")>0 then
 		meta:set_float("srcTime",0)
 		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
 	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryTake(self,pos,listname,index,stack,player)
 end
 function industrialtest.CanningMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local fuelSlot=inv:get_stack("src",1)
 	local targetSlot=inv:get_stack("dst",1)
 	if ((fromList=="src" and count==fuelSlot:get_count()) or (fromList=="dst" and count==targetSlot:get_count())) and meta:get_float("srcTime")>0 then
 		meta:set_float("srcTime",0)
 		meta:set_string("formspec",canningMachine.getFormspec(pos))
 	end
 end
 function industrialtest.CanningMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
 	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
 end
 function industrialtest.CanningMachine.shouldActivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local fuelSlot=inv:get_stack("src",1)
 	local targetSlot=inv:get_stack("dst",1)
 	local leftoverSlot=inv:get_stack("leftover",1)
 	local powerStorageSlot=inv:get_stack("powerStorage",1)
 	local targetMeta=targetSlot:get_meta()
 	local def=fuelSlot:get_definition()
 	return not fuelSlot:is_empty() and not targetSlot:is_empty() and meta:get_int("industrialtest.powerAmount")>=self._opPower and (not def._industrialtest_emptyVariant or leftoverSlot:item_fits(ItemStack(def._industrialtest_emptyVariant))) and
 		(not industrialtest.api.itemHasFluidStorage(fuelSlot) or fuelSlot:get_meta():get_int("industrialtest.fluidAmount")>0) and targetMeta:get_int("industrialtest.fluidAmount")<targetMeta:get_int("industrialtest.fluidCapacity")
 end
 function industrialtest.CanningMachine.shouldDeactivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local fuelSlot=inv:get_stack("src",1)
 	local fuelDef=fuelSlot:get_definition()
 	local targetSlot=inv:get_stack("dst",1)
 	local targetMeta=targetSlot:get_meta()
 	local leftoverSlot=inv:get_stack("leftover",1)
 	return fuelSlot:is_empty() or targetSlot:is_empty() or meta:get_int("industrialtest.powerAmount")<self._opPower or
 		(industrialtest.api.itemHasFluidStorage(fuelSlot) and industrialtest.api.isItemFluidStorageEmpty(fuelSlot)) or
 		industrialtest.api.isItemFluidStorageFull(targetSlot) or
 		targetMeta:get_int("industrialtest.fluidCapacity")-targetMeta:get_int("industrialtest.fluidAmount")<fuelDef._industrialtest_fuelAmount or
 		(fuelDef._industrialtest_emptyVariant and not leftoverSlot:item_fits(ItemStack(fuelDef._industrialtest_emptyVariant)))
 end
 function industrialtest.CanningMachine.afterDeactivation(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local targetSlot=inv:get_stack("dst",1)
 	if meta:get_int("industrialtest.powerAmount")>=self._opPower or industrialtest.api.isItemFluidStorageFull(targetSlot) then
 		meta:set_float("srcTime",0)
 	end
 	self:updateFormspec(pos)
 end
 function industrialtest.CanningMachine.activeUpdate(self,pos,elapsed,meta,inv)
 	local shouldUpdateFormspec=false
 	local fuelSlot=inv:get_stack("src",1)
 	local targetSlot=inv:get_stack("dst",1)
 	local powerStorageSlot=inv:get_stack("powerStorage",1)
 	local fuelMeta=fuelSlot:get_meta()
 	local targetMeta=targetSlot:get_meta()
 	local srcTime=meta:get_float("srcTime")+elapsed*industrialtest.api.getMachineSpeed(meta)
 	if srcTime>=self._canningTime then
 		if industrialtest.api.itemHasFluidStorage(fuelSlot) then
 			industrialtest.api.transferFluidToItem(fuelSlot,targetSlot,fuelMeta:get_int("industrialtest.fluidAmount"))
 			inv:set_stack("src",1,fuelSlot)
 			inv:set_stack("dst",1,targetSlot)
 		else
 			local def=fuelSlot:get_definition()
 			local leftoverSlot=inv:get_stack("leftover",1)
 			if targetMeta:get_int("industrialtest.fluidCapacity")-targetMeta:get_int("industrialtest.fluidAmount")<def._industrialtest_fuelAmount or (def._industrialtest_emptyVariant and not leftoverSlot:item_fits(ItemStack(def._industrialtest_emptyVariant))) then
 				return shouldUpdateFormspec
 			end
 			industrialtest.api.addFluidToItem(targetSlot,def._industrialtest_fuelAmount)
 			inv:set_stack("dst",1,targetSlot)
 			fuelSlot:take_item(1)
 			inv:set_stack("src",1,fuelSlot)
 			leftoverSlot:add_item(ItemStack(def._industrialtest_emptyVariant))
 			inv:set_stack("leftover",1,leftoverSlot)
 		end
 		meta:set_float("srcTime",0)
 	else
 		meta:set_float("srcTime",srcTime)
 	end
 	industrialtest.api.addPower(meta,-self._opPower)
 	return true
 end
 industrialtest.CanningMachine:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:canning_machine",
 	recipe={
 		{industrialtest.elementKeys.tinIngot,"industrialtest:electronic_circuit",industrialtest.elementKeys.tinIngot},
 		{industrialtest.elementKeys.tinIngot,"industrialtest:machine_block",industrialtest.elementKeys.tinIngot},
 		{industrialtest.elementKeys.tinIngot,industrialtest.elementKeys.tinIngot,industrialtest.elementKeys.tinIngot}
 	}
 })
--- a/machines/chargepad.lua
+++ b/machines/chargepad.lua
@@ -0,0 +1,300 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
 industrialtest.internal.chargepads={}
 industrialtest.Chargepad=table.copy(industrialtest.ActivatedElectricMachine)
 industrialtest.internal.unpackTableInto(industrialtest.Chargepad,{
 	storageLists={
 		"charged",
 		"discharged"
 	},
 	powerLists={
 		{
 			list="charged",
 			direction="o"
 		},
 		{
 			list="discharged",
 			direction="i"
 		}
 	},
 	facedir=true,
 	ioConfig="iiiioi",
 	hasPowerInput=true,
 	hasPowerOutput=true
 })
 function industrialtest.Chargepad.onConstruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	inv:set_size("charged",1)
 	inv:set_size("discharged",1)
 	meta:set_int("active",0)
 	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
 end
 function industrialtest.Chargepad.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
 	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
 	local formspec={
 		"list[context;charged;1,2.5;1,1]",
 		industrialtest.internal.getItemSlotBg(1,2.5,1,1),
 		"label[0.9,3.9;"..S("Charge").."]",
 		"list[context;discharged;3,2.5;1,1]",
 		industrialtest.internal.getItemSlotBg(3,2.5,1,1),
 		"label[2.7,3.9;"..S("Discharge").."]",
 		self.createPowerIndicatorWidget(charged,9,1),
 		"listring[context;charged]",
 		"listring[context;discharged]"
 	}
 	return parentFormspec..table.concat(formspec,"")
 end
 function industrialtest.Chargepad.register(self)
 	industrialtest.ActivatedElectricMachine.register(self)
 	table.insert(industrialtest.internal.chargepads,self.name)
 	table.insert(industrialtest.internal.chargepads,self.name.."_active")
 	minetest.register_craft({
 		type="shaped",
 		output=self.name,
 		recipe={
 			{"industrialtest:electronic_circuit",industrialtest.elementKeys.stoneSlab,"industrialtest:electronic_circuit"},
 			{industrialtest.elementKeys.rubber,self._basePowerStorage,industrialtest.elementKeys.rubber}
 		}
 	})
 end
 function industrialtest.Chargepad.chargePlayer(meta,player,flow)
 	local inv
 	if industrialtest.mtgAvailable then
 		_,inv=armor:get_valid_player(player,"")
 		if not inv then
 			return false
 		end
 	elseif industrialtest.mclAvailable then
 		inv=player:get_inventory()
 	end
 	local armorList=inv:get_list("armor")
 	local chargedSlots={}
 	for i,stack in ipairs(armorList) do
 		local stackMeta=stack:get_meta()
 		if industrialtest.api.hasPowerStorage(stackMeta) and not industrialtest.api.isFullyCharged(stackMeta) then
 			table.insert(chargedSlots,{
 				index=i,
 				stack=stack
 			})
 		end
 	end
 	local wielded=player:get_wielded_item()
 	if not wielded:is_empty() then
 		local wieldedMeta=wielded:get_meta()
 		if industrialtest.api.hasPowerStorage(wieldedMeta) and not industrialtest.api.isFullyCharged(wieldedMeta) then
 			table.insert(chargedSlots,{
 				stack=wielded
 			})
 		end
 	end
 	if #chargedSlots==0 then
 		return false
 	end
 	local distribution=math.min(flow,meta:get_int("industrialtest.powerAmount"))/#chargedSlots
 	for _,chargedSlot in ipairs(chargedSlots) do
 		industrialtest.api.transferPowerToItem(meta,chargedSlot.stack,distribution)
 		if chargedSlot.index then
 			inv:set_stack("armor",chargedSlot.index,chargedSlot.stack)
 		else
 			player:set_wielded_item(chargedSlot.stack)
 		end
 	end
 	return true
 end
 function industrialtest.Chargepad.action(self,pos,node)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local chargedSlot=inv:get_stack("charged",1)
 	local dischargedSlot=inv:get_stack("discharged",1)
 	local _,shouldUpdateFormspec=industrialtest.api.powerFlow(pos)
 	local flow=meta:get_int("industrialtest.powerFlow")
 	if chargedSlot:get_count()>0 and meta:get_int("industrialtest.powerAmount")>0 and industrialtest.api.transferPowerToItem(meta,chargedSlot,flow)>0 then
 		inv:set_stack("charged",1,chargedSlot)
 		shouldUpdateFormspec=true
 	end
 	if dischargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(meta) and industrialtest.api.transferPowerFromItem(dischargedSlot,meta,flow)>0 then
 		inv:set_stack("discharged",1,dischargedSlot)
 		shouldUpdateFormspec=true
 	end
 	local players=minetest.get_connected_players()
 	local p1=vector.offset(pos,-0.5,0,-0.5)
 	local p2=vector.offset(pos,0.5,2,0.5)
 	local playerFound=false
 	for _,player in ipairs(players) do
 		if vector.in_area(player:get_pos(),p1,p2) then
 			playerFound=true
 			shouldUpdateFormspec=shouldUpdateFormspec or self.chargePlayer(meta,player,flow)
 			break
 		end
 	end
 	local active=meta:get_int("active")==1
 	if playerFound and not active then
 		self:activate(pos)
 		meta:set_int("active",1)
 	elseif (not playerFound or meta:get_int("industrialtest.powerAmount")==0) and active then
 		self:deactivate(pos)
 		meta:set_int("active",0)
 	end
 	if shouldUpdateFormspec then
 		self:updateFormspec(pos)
 	end
 end
 industrialtest.BatboxChargepad=table.copy(industrialtest.Chargepad)
 industrialtest.internal.unpackTableInto(industrialtest.BatboxChargepad,{
 	name="industrialtest:batbox_chargepad",
 	description=S("BatBox Chargepad"),
 	tiles={
 		"industrialtest_wood_machine_block.png^industrialtest_chargepad_top.png",
 		"industrialtest_wood_machine_block.png",
 		"industrialtest_wood_machine_block.png",
 		"industrialtest_wood_machine_block.png",
 		"industrialtest_wood_machine_block.png",
 		"industrialtest_wood_machine_block.png^industrialtest_batbox_front.png"
 	},
 	sounds="wood",
 	active={
 		tiles={
 			"industrialtest_wood_machine_block.png^industrialtest_chargepad_top_active.png",
 			"industrialtest_wood_machine_block.png",
 			"industrialtest_wood_machine_block.png",
 			"industrialtest_wood_machine_block.png",
 			"industrialtest_wood_machine_block.png",
 			"industrialtest_wood_machine_block.png^industrialtest_batbox_front.png"
 		}
 	},
 	capacity=25000,
 	flow=industrialtest.api.lvPowerFlow,
 	_basePowerStorage="industrialtest:batbox"
 })
 industrialtest.BatboxChargepad:register()
 industrialtest.CESUChargepad=table.copy(industrialtest.Chargepad)
 industrialtest.internal.unpackTableInto(industrialtest.CESUChargepad,{
 	name="industrialtest:cesu_chargepad",
 	description=S("CESU Chargepad"),
 	tiles={
 		"industrialtest_bronze_machine_block.png^industrialtest_chargepad_top.png",
 		"industrialtest_bronze_machine_block.png",
 		"industrialtest_bronze_machine_block.png",
 		"industrialtest_bronze_machine_block.png",
 		"industrialtest_bronze_machine_block.png",
 		"industrialtest_bronze_machine_block.png^industrialtest_cesu_front.png"
 	},
 	sounds="metal",
 	active={
 		tiles={
 			"industrialtest_bronze_machine_block.png^industrialtest_chargepad_top_active.png",
 			"industrialtest_bronze_machine_block.png",
 			"industrialtest_bronze_machine_block.png",
 			"industrialtest_bronze_machine_block.png",
 			"industrialtest_bronze_machine_block.png",
 			"industrialtest_bronze_machine_block.png^industrialtest_cesu_front.png"
 		}
 	},
 	capacity=400000,
 	flow=industrialtest.api.mvPowerFlow,
 	_basePowerStorage="industrialtest:cesu"
 })
 industrialtest.CESUChargepad:register()
 industrialtest.MFEChargepad=table.copy(industrialtest.Chargepad)
 industrialtest.internal.unpackTableInto(industrialtest.MFEChargepad,{
 	name="industrialtest:mfe_chargepad",
 	description=S("MFE Chargepad"),
 	tiles={
 		"industrialtest_machine_block.png^industrialtest_chargepad_top.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_mfe_front.png"
 	},
 	sounds="metal",
 	requiresWrench=true,
 	active={
 		tiles={
 			"industrialtest_machine_block.png^industrialtest_chargepad_top_active.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_mfe_front.png"
 		}
 	},
 	capacity=3000000,
 	flow=industrialtest.api.hvPowerFlow,
 	_basePowerStorage="industrialtest:mfe"
 })
 industrialtest.MFEChargepad:register()
 industrialtest.MFSUChargepad=table.copy(industrialtest.Chargepad)
 industrialtest.internal.unpackTableInto(industrialtest.MFSUChargepad,{
 	name="industrialtest:mfsu_chargepad",
 	description=S("MFSU Chargepad"),
 	tiles={
 		"industrialtest_advanced_machine_block.png^industrialtest_chargepad_top.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png^industrialtest_mfsu_front.png"
 	},
 	sounds="metal",
 	requiresWrench=true,
 	active={
 		tiles={
 			"industrialtest_advanced_machine_block.png^industrialtest_chargepad_top_active.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png^industrialtest_mfsu_front.png"
 		}
 	},
 	capacity=30000000,
 	flow=industrialtest.api.evPowerFlow,
 	_basePowerStorage="industrialtest:mfsu"
 })
 industrialtest.MFSUChargepad:register()
 minetest.register_abm({
 	label="Chargepad updating",
 	nodenames=industrialtest.internal.chargepads,
 	interval=industrialtest.updateDelay,
 	chance=1,
 	action=function(pos,node)
 		local def=minetest.registered_nodes[node.name]
 		def._industrialtest_self:action(pos,node)
 	end
 })
--- a/machines/common.lua
+++ b/machines/common.lua
@@ -1,758 +0,0 @@
 -- IndustrialTest
 -- Copyright (C) 2023 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local machine={}
 local simpleElectricItemProcessor={}
 industrialtest.internal.mclAfterDigNode=function(pos,oldmeta,lists)
 	-- Taken from https://git.minetest.land/MineClone2/MineClone2/src/branch/master/mods/ITEMS/mcl_furnaces/init.lua#L538
 	local meta=minetest.get_meta(pos)
 	local meta2=meta
 	meta:from_table(oldmeta)
 	local inv=meta:get_inventory()
 	for _,listname in ipairs(lists) do
 		local stack=inv:get_stack(listname,1)
 		if not stack:is_empty() then
 			local p = {x=pos.x+math.random(0, 10)/10-0.5, y=pos.y, z=pos.z+math.random(0, 10)/10-0.5}
 			minetest.add_item(p, stack)
 		end
 	end
 	meta:from_table(meta2:to_table())
 end
 industrialtest.internal.allowMoveToUpgradeSlot=function(pos,toIndex,stack)
 	local def=minetest.registered_items[stack:get_name()]
 	if not def or not def.groups or not def.groups._industrialtest_machineUpgrade then
 		return 0
 	end
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local targetSlot=inv:get_stack("upgrades",toIndex)
 	if not targetSlot:is_empty() then
 		return 0
 	end
 	return stack:get_count()
 end
 machine.getFormspec=function(pos,config)
 	local formspec
 	if industrialtest.mtgAvailable then
 		formspec={
 			"formspec_version[4]",
 			"size[10.8,12]",
 			"label[0.5,0.5;"..config.displayName.."]",
 			(config.getFormspec and config.getFormspec(pos) or ""),
 			"list[current_player;main;0.5,6.25;8,1]",
 			"list[current_player;main;0.5,7.5;8,3;8]"
 		}
 	elseif industrialtest.mclAvailable then
 		formspec={
 			"size[10.04,12]",
 			"label[0.25,0.25;"..config.displayName.."]",
 			(config.getFormspec and config.getFormspec(pos) or ""),
 			"list[current_player;main;0.5,7;9,3;9]",
 			mcl_formspec.get_itemslot_bg(0.5,7,9,3),
 			"list[current_player;main;0.5,10.24;9,1]",
 			mcl_formspec.get_itemslot_bg(0.5,10.24,9,1)
 		}
 	end
 	return table.concat(formspec,"")
 end
 machine.onConstruct=function(pos,config)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	industrialtest.api.addPowerStorage(meta,config.capacity,config.flow,config.ioConfig)
 	if not config.withoutFormspec then
 		meta:set_string("formspec",machine.getFormspec(pos,config))
 	end
 	if config.groups then
 		if config.groups._industrialtest_hasPowerInput then
 			local connections=industrialtest.api.getConnections(pos)
 			for _,conn in ipairs(connections) do
 				local connectionMeta=minetest.get_meta(conn)
 				if industrialtest.api.isNetworkMaster(connectionMeta) then
 					industrialtest.api.createNetworkMapForNode(conn)
 					minetest.get_node_timer(conn):start(industrialtest.updateDelay)
 				else
 					local def=minetest.registered_nodes[minetest.get_node(conn).name]
 					if def.groups._industrialtest_cable then
 						local networks=industrialtest.api.isAttachedToNetwork(connectionMeta)
 						if networks then
 							for _,network in ipairs(networks) do
 								industrialtest.api.createNetworkMapForNode(network)
 								minetest.get_node_timer(network):start(industrialtest.updateDelay)
 							end
 						end
 					end
 				end
 			end
 		end
 		if config.groups._industrialtest_hasPowerOutput then
 			meta:set_string("industrialtest.network",minetest.serialize(industrialtest.api.createNetworkMap(pos)))
 		end
 	end
 	if config.onConstruct then
 		config.onConstruct(pos,meta,inv)
 	end
 	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 end
 machine.onDestruct=function(pos)
 	local meta=minetest.get_meta(pos)
 	if industrialtest.api.isNetworkMaster(meta) then
 		local network=industrialtest.api.createNetworkMap(pos,true)
 		for _,endpoint in ipairs(network) do
 			local endpointMeta=minetest.get_meta(endpoint.position)
 			local networks=industrialtest.api.isAttachedToNetwork(endpointMeta)
 			for key,value in ipairs(networks) do
 				if value.x==pos.x and value.y==pos.y and value.z==pos.z then
 					table.remove(networks,key)
 					break
 				end
 			end
 			endpointMeta:set_string("industrialtest.networks",minetest.serialize(networks))
 		end
 	else
 		local networks=industrialtest.api.isAttachedToNetwork(meta)
 		if networks then
 			for _,network in ipairs(networks) do
 				industrialtest.api.removeNodeFromNetwork(network,pos)
 			end
 		end
 	end
 end
 machine.onTimer=function(pos,elapsed,config)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local shouldRerunTimer=false
 	local shouldUpdateFormspec=false
 	if config.onTimer then
 		shouldRerunTimer,shouldUpdateFormspec=config.onTimer(pos,elapsed,meta,inv)
 	end
 	local def=minetest.registered_nodes[minetest.get_node(pos).name]
 	if def.groups and def.groups._industrialtest_hasPowerInput and not industrialtest.api.isFullyCharged(meta) then
 		local networks=industrialtest.api.isAttachedToNetwork(meta)
 		if networks then
 			for _,network in ipairs(networks) do
 				minetest.get_node_timer(network):start(industrialtest.updateDelay)
 			end
 		end
 	end
 	if shouldUpdateFormspec then
 		machine.updateFormspec(pos,config)
 	end
 	return shouldRerunTimer
 end
 machine.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count,config)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local movedItemStack=inv:get_stack(fromList,1)
 	if toList=="upgrades" then
 		return industrialtest.internal.allowMoveToUpgradeSlot(pos,toIndex,movedItemStack)
 	end
 	local found=false
 	if config.powerSlots then
 		for _,value in ipairs(config.powerSlots) do
 			if value==toList then
 				found=true
 				break
 			end
 		end
 	end
 	if found and not industrialtest.api.hasPowerStorage(movedItemStack:get_meta()) then
 		return 0
 	end
 	if config.allowMetadataInventoryMove then
 		return config.allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count)
 	end
 	return count
 end
 machine.allowMetadataInventoryPut=function(pos,listname,index,stack,player,config)
 	if listname=="upgrades" then
 		return industrialtest.internal.allowMoveToUpgradeSlot(pos,index,stack)
 	end
 	local found=false
 	if config.powerSlots then
 		for _,value in ipairs(config.powerSlots) do
 			if value==listname then
 				found=true
 				break
 			end
 		end
 	end
 	if found and not industrialtest.api.hasPowerStorage(stack:get_meta()) then
 		return 0
 	end
 	if config.allowMetadataInventoryPut then
 		return config.allowMetadataInventoryPut(pos,listname,index,stack,player)
 	end
 	return stack:get_count()
 end
 machine.onMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
 	if toList=="upgrades" then
 		local meta=minetest.get_meta(pos)
 		local inv=meta:get_inventory()
 		local stack=inv:get_stack(fromList,fromIndex)
 		industrialtest.internal.applyUpgrade(pos,meta,stack)
 	elseif fromList=="upgrades" then
 		local meta=minetest.get_meta(pos)
 		local inv=meta:get_inventory()
 		local stack=inv:get_stack(fromList,fromIndex)
 		industrialtest.internal.removeUpgrade(pos,meta,stack)
 	end
 end
 machine.onMetadataInventoryPut=function(pos,listname,index,stack)
 	if listname=="upgrades" then
 		local meta=minetest.get_meta(pos)
 		industrialtest.internal.applyUpgrade(pos,meta,stack)
 	end
 end
 machine.onMetadataInventoryTake=function(pos,listname,index,stack)
 	if listname=="upgrades" then
 		local meta=minetest.get_meta(pos)
 		industrialtest.internal.removeUpgrade(pos,meta,stack)
 	end
 end
 machine.updateFormspec=function(pos,config)
 	if config.withoutFormspec then
 		return
 	end
 	local meta=minetest.get_meta(pos)
 	meta:set_string("formspec",machine.getFormspec(pos,config))
 end
 function industrialtest.internal.registerMachine(config)
 	local definition={
 		description=config.displayName,
 		on_construct=function(pos)
 			machine.onConstruct(pos,config)
 		end,
 		on_destruct=machine.onDestruct,
 		on_timer=function(pos,elapsed)
 			local shouldRerunTimer,_=machine.onTimer(pos,elapsed,config)
 			return shouldRerunTimer
 		end,
 		allow_metadata_inventory_move=function(pos,fromList,fromIndex,toList,toIndex,count)
 			return machine.allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count,config)
 		end,
 		allow_metadata_inventory_put=function(pos,listname,index,stack,player)
 			return machine.allowMetadataInventoryPut(pos,listname,index,stack,player,config)
 		end,
 		on_metadata_inventory_put=function(pos,listname,index,stack,player)
 			machine.onMetadataInventoryPut(pos,listname,index,stack)
 			if config.onMetadataInventoryPut then
 				config.onMetadataInventoryPut(pos,listname,index,stack,player)
 			end
 		end,
 		on_metadata_inventory_move=function(pos,fromList,fromIndex,toList,toIndex,count)
 			machine.onMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex)
 			if config.onMetadataInventoryPut then
 				config.onMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count)
 			end
 		end,
 		on_metadata_inventory_take=function(pos,listname,index,stack,player)
 			machine.onMetadataInventoryTake(pos,listname,index,stack)
 			if config.onMetadataInventoryTake then
 				config.onMetadataInventoryTake(pos,listname,index,stack,player)
 			end
 		end,
 		_industrialtest_updateFormspec=function(pos)
 			machine.updateFormspec(pos,config)
 		end
 	}
 	if industrialtest.mtgAvailable then
 		definition.groups={cracky=2}
 		if config.sounds=="metal" then
 			definition.sounds=default.node_sound_metal_defaults()
 		end
 		definition.can_dig=function(pos)
 			local meta=minetest.get_meta(pos)
 			local inv=meta:get_inventory()
 			for _,value in ipairs(config.storageSlots) do
 				if inv:get_stack(value,1):get_count()>0 then
 					return false
 				end
 			end
 			return true
 		end
 	elseif industrialtest.mclAvailable then
 		definition.after_dig_node=function(pos,oldnode,oldmeta)
 			industrialtest.internal.mclAfterDigNode(pos,oldmeta,config.storageSlots)
 		end
 		if config.sounds=="metal" then
 			definition.sounds=mcl_sounds.node_sound_metal_defaults()
 		end
 		definition.groups={pickaxey=1}
 		definition._mcl_blast_resistance=3.5
 		definition._mcl_hardness=3.9
 	end
 	definition.groups._industrialtest_wrenchUnmountable=1
 	if config.requiresWrench then
 		definition.drop="industrialtest:machine_block"
 	end
 	if config.customKeys then
 		for key,value in pairs(config.customKeys) do
 			definition[key]=value
 		end
 	end
 	if config.groups then
 		for key,value in pairs(config.groups) do
 			definition.groups[key]=value
 		end
 	end
 	minetest.register_node("industrialtest:"..config.name,definition)
 	if config.registerActiveVariant then
 		definition=table.copy(definition)
 		definition.description=nil
 		definition.on_timer=function(pos,elapsed)
 			local meta=minetest.get_meta(pos)
 			local inv=meta:get_inventory()
 			local shouldRerunTimer=false
 			local shouldUpdateFormspec=false
 			if config.activeOnTimer then
 				shouldRerunTimer,shouldUpdateFormspec=config.activeOnTimer(pos,elapsed,meta,inv)
 			end
 			local def=minetest.registered_nodes[minetest.get_node(pos).name]
 			if def.groups and def.groups._industrialtest_hasPowerInput and not industrialtest.api.isFullyCharged(meta) then
 				local networks=industrialtest.api.isAttachedToNetwork(meta)
 				if networks then
 					for _,network in ipairs(networks) do
 						minetest.get_node_timer(network):start(industrialtest.updateDelay)
 					end
 				end
 			end
 			if shouldUpdateFormspec then
 				machine.updateFormspec(pos,config)
 			end
 			return shouldRerunTimer
 		end
 		if not definition.drop then
 			definition.drop="industrialtest:"..config.name
 		end
 		if config.activeCustomKeys then
 			for key,value in pairs(config.activeCustomKeys) do
 				definition[key]=value
 			end
 		end
 		if industrialtest.mclAvailable then
 			definition.groups.not_in_creative_inventory=1
 			definition._doc_items_create_entry=false
 		end
 		minetest.register_node("industrialtest:"..config.name.."_active",definition)
 	end
 end
 local function craftResultProxy(method,item)
 	if method=="cooking" then
 		local output,after=minetest.get_craft_result({
 			method=method,
 			width=1,
 			items={item}
 		})
 		return {
 			item=output.item,
 			time=output.time,
 			src=after.items[1]
 		}
 	elseif method=="industrialtest.macerating" then
 		local output=industrialtest.api.getMaceratorRecipeResult(item:get_name())
 		if not output then
 			return {
 				item=ItemStack(),
 				time=0,
 				src=item
 			}
 		end
 		local srcAfter=ItemStack(item:get_name())
 		srcAfter:set_count(item:get_count()-1)
 		return {
 			item=ItemStack(output.output),
 			time=output.time,
 			src=srcAfter
 		}
 	elseif method=="industrialtest.compressing" then
 		local output=industrialtest.api.getCompressorRecipeResult(item:get_name())
 		if not output or item:get_count()<output.count then
 			return {
 				item=ItemStack(),
 				time=0,
 				src=item
 			}
 		end
 		local srcAfter=ItemStack(item:get_name())
 		srcAfter:set_count(item:get_count()-output.count)
 		return {
 			item=ItemStack(output.output),
 			time=output.time,
 			src=srcAfter
 		}
 	elseif method=="industrialtest.extracting" then
 		local output=industrialtest.api.getExtractorRecipeResult(item:get_name())
 		if not output then
 			return {
 				item=ItemStack(),
 				time=0,
 				src=item
 			}
 		end
 		local srcAfter=ItemStack(item:get_name())
 		srcAfter:set_count(item:get_count()-1)
 		return {
 			item=ItemStack(output.output),
 			time=output.time,
 			src=srcAfter
 		}
 	elseif method=="industrialtest.recycling" then
 		local srcAfter=ItemStack(item:get_name())
 		srcAfter:set_count(item:get_count()-1)
 		return {
 			item=ItemStack(industrialtest.random:next(1,8)==1 and "industrialtest:scrap" or ""),
 			time=2,
 			src=srcAfter
 		}
 	elseif method=="industrialtest.cable_forming" then
 		local output=industrialtest.api.getCableFormerRecipeResult(item:get_name())
 		if not output then
 			return {
 				item=ItemStack(),
 				time=0,
 				src=item
 			}
 		end
 		local srcAfter=ItemStack(item:get_name())
 		srcAfter:set_count(item:get_count()-1)
 		return {
 			item=ItemStack(output.output),
 			time=output.time,
 			src=srcAfter
 		}
 	elseif method=="industrialtest.mass_fabricating" then
 		if item:get_count()<34 then
 			return {
 				item=ItemStack(),
 				time=0,
 				src=item
 			}
 		end
 		local srcAfter=ItemStack(item:get_name())
 		srcAfter:set_count(item:get_count()-34)
 		return {
 			item=ItemStack("industrialtest:uu_matter"),
 			time=15,
 			src=srcAfter
 		}
 	end
 	error("Unknown craft method passed to craftResultProxy")
 end
 simpleElectricItemProcessor.getFormspec=function(pos)
 	local meta=minetest.get_meta(pos)
 	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
 	local srcPercent=meta:get_float("srcTime")/meta:get_float("maxSrcTime")*100
 	local formspec
 	if industrialtest.mtgAvailable then
 		formspec={
 			"list[context;src;3.4,1.8;1,1]",
 			"listring[context;src]",
 			(powerPercent>0 and "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
 			 or "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
 			"list[context;powerStorage;3.4,3.9;1,1]",
 			"listring[context;powerStorage]",
 			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
 			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
 			"list[context;dst;6.4,2.8;1,1]",
 			"listring[context;dst]",
 			"list[context;upgrades;9,0.9;1,4]",
 			"listring[context;upgrades]"
 		}
 	elseif industrialtest.mclAvailable then
 		formspec={
 			"list[context;src;3.4,1.8;1,1]",
 			mcl_formspec.get_itemslot_bg(3.4,1.8,1,1),
 			"listring[context;src]",
 			(powerPercent>0 and "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
 			 or "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
 			"list[context;powerStorage;3.4,3.9;1,1]",
 			mcl_formspec.get_itemslot_bg(3.4,3.9,1,1),
 			"listring[context;powerStorage]",
 			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
 			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
 			"list[context;dst;6.4,2.8;1,1]",
 			mcl_formspec.get_itemslot_bg(6.4,2.8,1,1),
 			"listring[context;dst]",
 			"list[context;upgrades;9,0.9;1,4]",
 			mcl_formspec.get_itemslot_bg(9,0.9,1,4),
 			"listring[context;upgrades]"
 		}
 	end
 	return table.concat(formspec,"")
 end
 simpleElectricItemProcessor.onPowerFlow=function(pos)
 	-- FIXME: this probably will require refactor so node timer won't be started
 	-- just to test if machine can process item
 	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 end
 simpleElectricItemProcessor.onConstruct=function(pos,meta,inv)
 	inv:set_size("src",1)
 	inv:set_size("dst",1)
 	inv:set_size("powerStorage",1)
 	inv:set_size("upgrades",4)
 	meta:set_float("srcTime",-1)
 	meta:set_float("maxSrcTime",0)
 end
 simpleElectricItemProcessor.onTimer=function(pos,elapsed,meta,inv,config)
 	local srcSlot=inv:get_stack("src",1)
 	local powerStorageSlot=inv:get_stack("powerStorage",1)
 	local shouldUpdateFormspec=false
 	local shouldRerunTimer=false
 	local requiredPower=elapsed*config.opPower*industrialtest.api.getMachineSpeed(meta)
 	if powerStorageSlot:get_count()>0 then
 		local stackMeta=powerStorageSlot:get_meta()
 		if industrialtest.api.transferPower(stackMeta,meta,stackMeta:get_int("industrialtest.powerFlow"))>0 then
 			shouldUpdateFormspec=true
 			shouldRerunTimer=true
 			industrialtest.api.updateItemPowerText(powerStorageSlot)
 			inv:set_stack("powerStorage",1,powerStorageSlot)
 		end
 	end
 	if srcSlot:get_count()>0 and meta:get_int("industrialtest.powerAmount")>=requiredPower then
 		local output=craftResultProxy(config.method,srcSlot)
 		if output.time>0 and inv:room_for_item("dst",output.item) then
 			if meta:get_float("maxSrcTime")<=0 then
 				meta:set_float("srcTime",0)
 				meta:set_float("maxSrcTime",output.time*config.efficiency)
 			end
 			minetest.swap_node(pos,{
 				name="industrialtest:"..config.name.."_active",
 				param2=minetest.get_node(pos).param2
 			})
 			minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 		end
 	end
 	return shouldRerunTimer,shouldUpdateFormspec
 end
 simpleElectricItemProcessor.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,count)
 	if toList=="dst" then
 		return 0
 	elseif toList=="upgrades" then
 		-- TODO: Add support for upgrades when they will be added
 		return 0
 	end
 	return count
 end
 simpleElectricItemProcessor.allowMetadataInventoryPut=function(pos,listname,index,stack)
 	if listname=="dst" then
 		return 0
 	elseif listname=="src" then
 		local meta=minetest.get_meta(pos)
 		local inv=meta:get_inventory()
 		local srcSlot=inv:get_stack("src",1)
 		if srcSlot:get_name()~=stack:get_name() then
 			meta:set_float("srcTime",-1)
 			meta:set_float("maxSrcTime",0)
 		end
 	elseif listname=="upgrades" then
 		--TODO: See allow_metadata_inventory_move
 		return 0
 	end
 	return stack:get_count()
 end
 simpleElectricItemProcessor.onMetadataInventoryPut=function(pos)
 	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 end
 simpleElectricItemProcessor.onMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcSlot=inv:get_stack("src",1)
 	local dstSlot=inv:get_stack("dst",1)
 	if fromList=="src" and count==srcSlot:get_count() then
 		meta:set_float("srcTime",-1)
 		meta:set_float("maxSrcTime",0)
 		if meta:get_int("industrialtest.powerAmount")>0 then
 			meta:set_string("formspec",simpleElectricItemProcessor.getFormspec(pos))
 		end
 	elseif fromList=="dst" and dstSlot:get_free_space()==0 then
 		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
 end
 simpleElectricItemProcessor.onMetadataInventoryTake=function(pos,listname,index,stack)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcSlot=inv:get_stack("src",1)
 	local dstSlot=inv:get_stack("dst",1)
 	if listname=="src" and stack:get_count()==srcSlot:get_count() then
 		meta:set_float("srcTime",-1)
 		meta:set_float("maxSrcTime",0)
 		if meta:get_int("industrialtest.powerAmount")>0 then
 			meta:set_string("formspec",simpleElectricItemProcessor.getFormspec(pos))
 		end
 	elseif listname=="dst" and dstSlot:get_free_space()==0 then
 		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
 end
 simpleElectricItemProcessor.activeOnTimer=function(pos,elapsed,meta,inv,config)
 	local srcSlot=inv:get_stack("src",1)
 	local powerStorageSlot=inv:get_stack("powerStorage",1)
 	local shouldUpdateFormspec=false
 	local shouldRerunTimer=false
 	local requiredPower=elapsed*config.opPower*industrialtest.api.getMachineSpeed(meta)
 	if powerStorageSlot:get_count()>0 then
 		local stackMeta=powerStorageSlot:get_meta()
 		if industrialtest.api.transferPower(stackMeta,meta,stackMeta:get_int("industrialtest.powerFlow"))>0 then
 			shouldUpdateFormspec=true
 			shouldRerunTimer=true
 			industrialtest.api.updateItemPowerText(powerStorageSlot)
 			inv:set_stack("powerStorage",1,powerStorageSlot)
 		end
 	end
 	if srcSlot:get_count()>0 and meta:get_float("maxSrcTime")<=0 and meta:get_int("industrialtest.powerAmount")>=requiredPower then
 		local output=craftResultProxy(config.method,srcSlot)
 		if output.time>0 and inv:room_for_item("dst",output.item) then
 			meta:set_float("srcTime",0)
 			meta:set_float("maxSrcTime",output.time*config.efficiency)
 		end
 	end
 	if srcSlot:get_count()==0 and meta:get_float("maxSrcTime")>0 then
 		meta:set_float("srcTime",-1)
 		meta:set_float("maxSrcTime",0)
 		shouldUpdateFormspec=true
 	end
 	if meta:get_float("maxSrcTime")>0 then
 		if meta:get_int("industrialtest.powerAmount")>=requiredPower then
 			meta:set_int("industrialtest.powerAmount",meta:get_int("industrialtest.powerAmount")-requiredPower)
 			meta:set_float("srcTime",meta:get_float("srcTime")+elapsed)
 			shouldRerunTimer=true
 		end
 		shouldUpdateFormspec=true
 	end
 	if meta:get_float("maxSrcTime")<=0 or meta:get_int("industrialtest.powerAmount")<requiredPower then
 		minetest.swap_node(pos,{
 			name="industrialtest:"..config.name,
 			param2=minetest.get_node(pos).param2
 		})
 		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
 	if meta:get_float("srcTime")>=meta:get_float("maxSrcTime") then
 		local output=craftResultProxy(config.method,srcSlot)
 		local speed=industrialtest.api.getMachineSpeed(meta)
 		local usedItems=srcSlot:get_count()-output.src:get_count()
 		local multiplier=1
 		if srcSlot:get_count()>=speed*usedItems then
 			multiplier=speed
 		end
 		if output.item:get_count()>0 then
 			output.item:set_count(output.item:get_count()*multiplier)
 			inv:add_item("dst",output.item)
 			meta:set_float("srcTime",-1)
 			meta:set_float("maxSrcTime",0)
 		end
 		srcSlot:set_count(srcSlot:get_count()-multiplier*usedItems)
 		inv:set_stack("src",1,srcSlot)
 	end
 	return shouldRerunTimer,shouldUpdateFormspec
 end
 function industrialtest.internal.registerSimpleElectricItemProcessor(config)
 	local machineBlockTexture=config.machineBlockTexture or "industrialtest_machine_block.png"
 	industrialtest.internal.registerMachine({
 		name=config.name,
 		displayName=config.displayName,
 		capacity=config.capacity,
 		getFormspec=simpleElectricItemProcessor.getFormspec,
 		flow=config.flow,
 		ioConfig="iiiiii",
 		requiresWrench=config.requiresWrench,
 		registerActiveVariant=true,
 		sounds="metal",
 		powerSlots={"powerStorage"},
 		storageSlots={"src","dst","powerStorage","upgrades"},
 		groups={
 			_industrialtest_hasPowerInput=1
 		},
 		customKeys={
 			tiles={
 				machineBlockTexture..(config.customTopTexture and "^industrialtest_"..config.name.."_top.png" or ""),
 				machineBlockTexture..(config.customBottomTexture and "^industrialtest_"..config.name.."_bottom.png" or ""),
 				machineBlockTexture..(config.customRightTexture and "^industrialtest_"..config.name.."_right.png" or ""),
 				machineBlockTexture..(config.customLeftTexture and "^industrialtest_"..config.name.."_left.png" or ""),
 				machineBlockTexture..(config.customBackTexture and "^industrialtest_"..config.name.."_back.png" or ""),
 				machineBlockTexture..(config.customFrontTexture and "^industrialtest_"..config.name.."_front.png" or "")
 			},
 			paramtype2="facedir",
 			legacy_facedir_simple=true,
 			_industrialtest_onPowerFlow=simpleElectricItemProcessor.onPowerFlow
 		},
 		activeCustomKeys={
 			tiles={
 				machineBlockTexture..(config.customTopTexture and "^industrialtest_"..config.name.."_top_active.png" or ""),
 				machineBlockTexture..(config.customBottomTexture and "^industrialtest_"..config.name.."_bottom_active.png" or ""),
 				machineBlockTexture..(config.customRightTexture and "^industrialtest_"..config.name.."_right_active.png" or ""),
 				machineBlockTexture..(config.customLeftTexture and "^industrialtest_"..config.name.."_left_active.png" or ""),
 				machineBlockTexture..(config.customBackTexture and "^industrialtest_"..config.name.."_back_active.png" or ""),
 				machineBlockTexture..(config.customFrontTexture and "^industrialtest_"..config.name.."_front_active.png" or "")
 			}
 		},
 		onConstruct=simpleElectricItemProcessor.onConstruct,
 		onTimer=function(pos,elapsed,meta,inv)
 			return simpleElectricItemProcessor.onTimer(pos,elapsed,meta,inv,config)
 		end,
 		allowMetadataInventoryMove=simpleElectricItemProcessor.allowMetadataInventoryMove,
 		allowMetadataInventoryPut=simpleElectricItemProcessor.allowMetadataInventoryPut,
 		onMetadataInventoryPut=simpleElectricItemProcessor.onMetadataInventoryPut,
 		onMetadataInventoryMove=simpleElectricItemProcessor.onMetadataInventoryMove,
 		onMetadataInventoryTake=simpleElectricItemProcessor.onMetadataInventoryTake,
 		activeOnTimer=function(pos,elapsed,meta,inv)
 			return simpleElectricItemProcessor.activeOnTimer(pos,elapsed,meta,inv,config)
 		end
 	})
 end
--- a/machines/compressor.lua
+++ b/machines/compressor.lua
@@ -15,18 +15,55 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-
+industrialtest.Compressor=table.copy(industrialtest.SimpleElectricItemProcessor)
-industrialtest.internal.registerSimpleElectricItemProcessor({
+industrialtest.internal.unpackTableInto(industrialtest.Compressor,{
-	name="compressor",
+	name="industrialtest:compressor",
-	displayName=S("Compressor"),
+	description=S("Compressor"),
-	customFrontTexture=true,
+	tiles={
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_compressor_front.png"
 	},
 	requiresWrench=true,
 	active={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_compressor_front_active.png"
 		}
 	},
 	capacity=1400,
 	flow=industrialtest.api.lvPowerFlow,
 	opPower=120,
 	method="industrialtest.compressing",
 	efficiency=1
 })
 function industrialtest.Compressor.getCraftResult(self,itemstack)
 	local output=industrialtest.api.getCompressorRecipeResult(itemstack:get_name())
 	if not output or itemstack:get_count()<output.count then
 		return {
 			item=ItemStack(),
 			time=0,
 			src=itemstack
 		}
 	end
 	local srcAfter=ItemStack(itemstack:get_name())
 	srcAfter:set_count(itemstack:get_count()-output.count)
 	return {
 		item=ItemStack(output.output),
 		time=output.time,
 		src=srcAfter
 	}
 end
 industrialtest.Compressor:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:compressor",
--- a/machines/electric_furnace.lua
+++ b/machines/electric_furnace.lua
@@ -15,17 +15,49 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-
+industrialtest.ElectricFurnace=table.copy(industrialtest.SimpleElectricItemProcessor)
-industrialtest.internal.registerSimpleElectricItemProcessor({
+industrialtest.internal.unpackTableInto(industrialtest.ElectricFurnace,{
-	name="electric_furnace",
+	name="industrialtest:electric_furnace",
-	displayName=S("Electric Furnace"),
+	description=S("Electric Furnace"),
-	customFrontTexture=true,
+	tiles={
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_electric_furnace_front.png"
 	},
 	active={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_electric_furnace_front_active.png"
 		}
 	},
 	capacity=416,
 	flow=industrialtest.api.lvPowerFlow,
 	opPower=60,
 	method="cooking",
 	efficiency=0.5
 })
 function industrialtest.ElectricFurnace.getCraftResult(self,itemstack)
 	local output,after=minetest.get_craft_result({
 		method="cooking",
 		width=1,
 		items={itemstack}
 	})
 	return {
 		item=output.item,
 		time=output.time,
 		src=after.items[1]
 	}
 end
 industrialtest.ElectricFurnace:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:electric_furnace",
--- a/machines/electric_machine.lua
+++ b/machines/electric_machine.lua
@@ -0,0 +1,243 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 industrialtest.ElectricMachine=table.copy(industrialtest.Machine)
 function industrialtest.ElectricMachine.onConstruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	industrialtest.api.addPowerStorage(meta,self.capacity,self.flow,self.ioConfig)
 	if self.hasPowerInput then
 		local connections=industrialtest.api.getConnections(pos)
 		for _,conn in ipairs(connections) do
 			local connectionMeta=minetest.get_meta(conn)
 			if industrialtest.api.isNetworkMaster(connectionMeta) then
 				industrialtest.api.createNetworkMapForNode(conn)
 				local def=minetest.get_node(conn)
 				if def and def._industrialtest_self then
 					def._industrialtest_self:flowPower(conn)
 				else
 					-- Support for bare definitions that don't use industrialtest pseudo-OOP
 					minetest.get_node_timer(conn):start(industrialtest.updateDelay)
 				end
 			else
 				local def=minetest.registered_nodes[minetest.get_node(conn).name]
 				if def.groups._industrialtest_cable then
 					local networks=industrialtest.api.isAttachedToNetwork(connectionMeta)
 					if networks then
 						for _,network in ipairs(networks) do
 							industrialtest.api.createNetworkMapForNode(network)
 							local def=minetest.registered_nodes[minetest.get_node(network).name]
 							if def and def._industrialtest_self then
 								def._industrialtest_self:flowPower(network)
 							else
 								-- Support for bare definitions that don't use industrialtest pseudo-OOP
 								minetest.get_node_timer(network):start(industrialtest.updateDelay)
 							end
 						end
 					end
 				end
 			end
 		end
 	end
 	if self.hasPowerOutput then
 		meta:set_string("industrialtest.network",minetest.serialize(industrialtest.api.createNetworkMap(pos)))
 	end
 	industrialtest.Machine.onConstruct(self,pos)
 end
 function industrialtest.ElectricMachine.onDestruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	if industrialtest.api.isNetworkMaster(meta) then
 		local network=industrialtest.api.createNetworkMap(pos,true)
 		for _,endpoint in ipairs(network) do
 			local endpointMeta=minetest.get_meta(endpoint.position)
 			local networks=industrialtest.api.isAttachedToNetwork(endpointMeta)
 			for key,value in ipairs(networks) do
 				if value.x==pos.x and value.y==pos.y and value.z==pos.z then
 					table.remove(networks,key)
 					break
 				end
 			end
 			endpointMeta:set_string("industrialtest.networks",minetest.serialize(networks))
 		end
 	end
 	local networks=industrialtest.api.isAttachedToNetwork(meta)
 	if networks then
 		for _,network in ipairs(networks) do
 			industrialtest.api.removeNodeFromNetwork(network,pos)
 		end
 	end
 	-- don't call onDestruct from parent class because it doesn't do anything
 end
 function industrialtest.ElectricMachine.onTimer(self,pos,elapsed)
 	local result=industrialtest.Machine.onTimer(self,pos,elapsed)
 	local result2=self:powerExchange(pos)
 	return result or result2
 end
 function industrialtest.ElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	local found=false
 	if self.powerLists then
 		for _,value in ipairs(self.powerLists) do
 			if value.list==toList then
 				found=true
 				break
 			end
 		end
 	end
 	if found and not industrialtest.api.hasPowerStorage(movedItemStack:get_meta()) then
 		return 0
 	end
 	return industrialtest.Machine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 end
 function industrialtest.ElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
 	local found=false
 	if self.powerLists then
 		for _,value in ipairs(self.powerLists) do
 			if value.list==listname then
 				found=true
 				break
 			end
 		end
 	end
 	if found and not industrialtest.api.hasPowerStorage(stack:get_meta()) then
 		return 0
 	end
 	return industrialtest.Machine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
 end
 function industrialtest.ElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	if self.powerLists then
 		for _,value in ipairs(self.powerLists) do
 			if value.list==toList then
 				self:trigger(pos)
 				break
 			end
 		end
 	end
 	industrialtest.Machine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 end
 function industrialtest.ElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
 	if self.powerLists then
 		for _,value in ipairs(self.powerLists) do
 			if value.list==listname then
 				self:trigger(pos)
 				break
 			end
 		end
 	end
 	industrialtest.Machine.onMetadataInventoryPut(self,pos,listname,index,stack)
 end
 function industrialtest.ElectricMachine.flowPower(self,pos)
 	if not self.hasPowerOutput then
 		return
 	end
 	local meta=minetest.get_meta(pos)
 	if meta:get_int("industrialtest.powerAmount")<=0 then
 		return
 	end
 	local _,flowTransferred=industrialtest.api.powerFlow(pos)
 	if flowTransferred then
 		self:updateFormspec(pos)
 	end
 	self:triggerIfNeeded(pos)
 end
 function industrialtest.ElectricMachine.requestPower(self,pos)
 	local meta=minetest.get_meta(pos)
 	local networks=industrialtest.api.isAttachedToNetwork(meta)
 	if networks then
 		for _,network in ipairs(networks) do
 			local def=minetest.registered_nodes[minetest.get_node(network).name]
 			if def and def._industrialtest_self then
 				def._industrialtest_self:flowPower(network)
 			else
 				-- Support for bare definitions that don't use industrialtest pseudo-OOP
 				minetest.get_node_timer(network):start(industrialtest.updateDelay)
 			end
 		end
 	end
 end
 function industrialtest.ElectricMachine.powerExchange(self,pos)
 	local meta=minetest.get_meta(pos)
 	local shouldRerunTimer=false
 	if self.hasPowerInput and not industrialtest.api.isFullyCharged(meta) then
 		self:requestPower(pos)
 		shouldRerunTimer=shouldRerunTimer or not industrialtest.api.isFullyCharged(meta)
 	end
 	if self.hasPowerOutput and meta:get_int("industrialtest.powerAmount")>0 then
 		local spaceAvailable,flowTransferred=industrialtest.api.powerFlow(pos)
 		if flowTransferred then
 			self:updateFormspec(pos)
 		end
 		shouldRerunTimer=shouldRerunTimer or spaceAvailable
 	end
 	if self.powerLists then
 		local inv=meta:get_inventory()
 		local powerFlow=meta:get_int("industrialtest.powerFlow")
 		for _,listDesc in ipairs(self.powerLists) do
 			local slot=inv:get_stack(listDesc.list,1)
 			if slot:get_count()>0 then
 				if listDesc.direction=="o" then
 					if meta:get_int("industrialtest.powerAmount")<=0 then
 						break
 					end
 					if not industrialtest.api.isFullyCharged(slot:get_meta()) then
 						industrialtest.api.transferPowerToItem(meta,slot,powerFlow)
 						inv:set_stack(listDesc.list,1,slot)
 						self:updateFormspec(pos)
 						shouldRerunTimer=shouldRerunTimer or (not industrialtest.api.isFullyCharged(slot:get_meta()) and meta:get_int("industrialtest.powerAmount")>0)
 					end
 				elseif listDesc.direction=="i" then
 					if industrialtest.api.isFullyCharged(meta) then
 						break
 					end
 					local slotMeta=slot:get_meta()
 					if slotMeta:get_int("industrialtest.powerAmount")>0 then
 						industrialtest.api.transferPowerFromItem(slot,meta,powerFlow)
 						inv:set_stack(listDesc.list,1,slot)
 						self:updateFormspec(pos)
 						shouldRerunTimer=shouldRerunTimer or (not industrialtest.api.isFullyCharged(meta) and slotMeta:get_int("industrialtest.powerAmount")>0)
 					end
 				end
 			end
 		end
 	end
 	return shouldRerunTimer
 end
 function industrialtest.ElectricMachine.createPowerIndicatorWidget(charged,x,y)
 	return table.concat({
 		string.format("box[%f,%f;0.3,4.8;#202020]",x,y),
 		(charged>0 and string.format("box[%f,%f;0.3,%f;#FF1010]",x,y+4.8-(charged*4.8),charged*4.8) or ""),
 	},"")
 end
--- a/machines/extractor.lua
+++ b/machines/extractor.lua
@@ -15,23 +15,60 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-
+industrialtest.Extractor=table.copy(industrialtest.SimpleElectricItemProcessor)
-industrialtest.internal.registerSimpleElectricItemProcessor({
+industrialtest.internal.unpackTableInto(industrialtest.Extractor,{
-	name="extractor",
+	name="industrialtest:extractor",
-	displayName=S("Extractor"),
+	description=S("Extractor"),
-	customFrontTexture=true,
+	tiles={
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_extractor_front.png"
 	},
 	requiresWrench=true,
-	capacity=900,
+	active={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_extractor_front_active.png"
 		}
 	},
 	capacity=1000,
 	flow=industrialtest.api.lvPowerFlow,
 	opPower=100,
 	method="industrialtest.extracting",
 	efficiency=1
 })
 function industrialtest.Extractor.getCraftResult(self,itemstack)
 	local output=industrialtest.api.getExtractorRecipeResult(itemstack:get_name())
 	if not output then
 		return {
 			item=ItemStack(),
 			time=0,
 			src=itemstack
 		}
 	end
 	local srcAfter=ItemStack(itemstack:get_name())
 	srcAfter:set_count(itemstack:get_count()-1)
 	return {
 		item=ItemStack(output.output),
 		time=output.time,
 		src=srcAfter
 	}
 end
 industrialtest.Extractor:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:extractor",
 	recipe={
-		{"industrialtest:treetap","industrialtest:machine_block","industrialtest:treetap"},
+		{industrialtest.elementKeys.treetap,"industrialtest:machine_block",industrialtest.elementKeys.treetap},
-		{"industrialtest:treetap","industrialtest:electronic_circuit","industrialtest:treetap"}
+		{industrialtest.elementKeys.treetap,"industrialtest:electronic_circuit",industrialtest.elementKeys.treetap}
 	}
 })
--- a/machines/fluid_generator.lua
+++ b/machines/fluid_generator.lua
@@ -15,252 +15,349 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
 local fluidGenerator={}
-fluidGenerator.getFormspec=function(pos,config)
+-- Common functions
 local function onConstruct(pos)
 	local meta=minetest.get_meta(pos)
-	local fluidPercent=meta:get_float("fluidAmount")/100
+	local inv=meta:get_inventory()
 	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
 	local fluid=meta:get_string("fluid")
 	local formspec
 	local fuel=config.getFuel(fluid)
 	local tile=(fuel and fuel.texture or "industrialtest_gui_fluid_bg.png")
 	if industrialtest.mtgAvailable then
 		formspec={
 			"list[context;fluid;2,1.8;1,1]",
 			"listring[context;fluid]",
 			(fluidPercent>0 and "image[2,3;1,1;industrialtest_gui_fluid_bg.png^[lowpart:"..fluidPercent..":"..tile.."]" or "image[2,3;1,1;industrialtest_gui_fluid_bg.png]"),
 			"list[context;leftover;2,4.2;1,1]",
 			"listring[context;leftover]",
 			"list[context;charged;6,3;1,1]",
 			"listring[context;charged]",
 			"box[9,1;0.3,4.8;#202020]",
 			(powerPercent>0 and "box[9,"..(1+4.8-(powerPercent*4.8))..";0.3,"..(powerPercent*4.8)..";#FF1010]" or "")
 		}
 	elseif industrialtest.mclAvailable then
 		formspec={
 			"list[context;fluid;2,1.8;1,1]",
 			mcl_formspec.get_itemslot_bg(2,1.8,1,1),
 			"listring[context;fluid]",
 			(fluidPercent>0 and "image[2,3;1,1;industrialtest_gui_fluid_bg.png^[lowpart:"..fluidPercent..":"..tile.."]" or "image[2,3;1,1;industrialtest_gui_fluid_bg.png]"),
 			"list[context;leftover;2,4.2;1,1]",
 			mcl_formspec.get_itemslot_bg(2,4.2,1,1),
 			"listring[context;leftover]",
 			"list[context;charged;6,3;1,1]",
 			mcl_formspec.get_itemslot_bg(6,3,1,1),
 			"listring[context;charged]",
 			"box[9,1;0.3,4.8;#202020]",
 			(powerPercent>0 and "box[9,"..(1+4.8-(powerPercent*4.8))..";0.3,"..(powerPercent*4.8)..";#FF1010]" or "")
 		}
 	end
 	return table.concat(formspec,"")
 end
 fluidGenerator.onConstruct=function(pos,meta,inv)
 	inv:set_size("charged",1)
-	inv:set_size("fluid",1)
+	inv:set_size("src",1)
-	inv:set_size("leftover",1)
+	inv:set_size("dst",1)
 	meta:set_float("fluidAmount",0)
 	meta:set_string("fluid","")
 end
-fluidGenerator.onTimer=function(pos,elapsed,meta,inv,config)
+local function getFormspec(self,pos)
-	local fluidSlot=inv:get_stack("fluid",1)
+	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
-	local chargedSlot=inv:get_stack("charged",1)
+	local meta=minetest.get_meta(pos)
-	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
+	local fluidPercent=meta:get_float("fluidAmount")/100
-	local shouldUpdateFormspec=false
+	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
-	local shouldRerunTimer=(afterFlow and meta:get_int("industrialtest.powerAmount")>0)
+	local fluid=meta:get_string("fluid")
-	if fluidSlot:get_count()>0 and meta:get_float("fluidAmount")<=9000 then
+	local fuel=self.getFuel(fluid)
-		local fuel=config.getFuelByItem(fluidSlot:get_name())
+	local tile=(fuel and fuel.texture or "industrialtest_gui_fluid_bg.png")
-		if fuel and (fuel.name==meta:get_string("fluid") or meta:get_string("fluid")=="") then
+	local formspec={
-			local leftover=false
+		"list[context;src;2,1.8;1,1]",
-			local leftoverAddingSucceeded=false
+		industrialtest.internal.getItemSlotBg(2,1.8,1,1),
-			for _,item in ipairs(fuel.storageItems) do
+		(fluidPercent>0 and "image[2,3;1,1;industrialtest_gui_fluid_bg.png^[lowpart:"..fluidPercent..":"..tile.."]" or "image[2,3;1,1;industrialtest_gui_fluid_bg.png]"),
-				if item.name==fluidSlot:get_name() and item.leftover then
+		"list[context;dst;2,4.2;1,1]",
-					if inv:room_for_item("leftover",ItemStack(item.leftover)) then
+		industrialtest.internal.getItemSlotBg(2,4.2,1,1),
-						inv:add_item("leftover",ItemStack(item.leftover))
+		"list[context;charged;6,3;1,1]",
-						leftoverAddingSucceeded=true
+		industrialtest.internal.getItemSlotBg(6,3,1,1),
-					end
+		self.createPowerIndicatorWidget(powerPercent,9,1),
-					leftover=true
+		"listring[context;src]",
-				end
+		"listring[context;dst]"
-			end
+	}
-			if not leftover or leftoverAddingSucceeded then
+	return parentFormspec..table.concat(formspec,"")
 				fluidSlot:take_item()
 				inv:set_stack("fluid",1,fluidSlot)
 				meta:set_string("fluid",fuel.name)
 				meta:set_float("fluidAmount",meta:get_float("fluidAmount")+1000)
 				shouldUpdateFormspec=true
 				shouldRerunTimer=false
 			end
 		end
 	end
 	if meta:get_float("fluidAmount")>=50 and not industrialtest.api.isFullyCharged(meta) then
 		meta:set_float("fluidAmount",meta:get_int("fluidAmount")-50*elapsed)
 		local toAdd=math.ceil(config.getFuel(meta:get_string("fluid")).calorificValue*elapsed)
 		industrialtest.api.addPower(meta,toAdd)
 		shouldUpdateFormspec=true
 		if config.registerActiveVariant then
 			minetest.swap_node(pos,{
 				name="industrialtest:"..config.name.."_active",
 				param2=minetest.get_node(pos).param2
 			})
 			minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 		else
 			shouldRerunTimer=true
 		end
 	end
 	if chargedSlot:get_count()>0 and meta:get_int("industrialtest.powerAmount")>0 then
 		if industrialtest.api.transferPowerToItem(meta,chargedSlot,industrialtest.api.lvPowerFlow)>0 then
 			inv:set_stack("charged",1,chargedSlot)
 			shouldUpdateFormspec=true
 			shouldRerunTimer=true
 		end
 	end
 	if flowTransferred then
 		shouldUpdateFormspec=true
 	end
 	return shouldRerunTimer,shouldUpdateFormspec
 end
-fluidGenerator.metadataChange=function(pos)
+local function allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count)
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	if toList=="dst" then
 		return 0
 	end
 	return count
 end
-fluidGenerator.activeOnTimer=function(pos,elapsed,meta,inv,config)
+local function allowMetadataInventoryPut(pos,listname,index,stack,player)
-	local fluidSlot=inv:get_stack("fluid",1)
+	if listname=="dst" then
-	local chargedSlot=inv:get_stack("charged",1)
+		return 0
-	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
+	end
-	local shouldUpdateFormspec=false
+	return stack:get_count()
-	local shouldRerunTimer=(afterFlow and meta:get_int("industrialtest.powerAmount")>0)
+end
-	if fluidSlot:get_count()>0 and meta:get_float("fluidAmount")<=9000 then
+local function takeFuelFromItem(self,pos)
-		local fuel=config.getFuelByItem(fluidSlot:get_name())
+	local meta=minetest.get_meta(pos)
-		if fuel and (fuel.name==meta:get_string("fluid") or meta:get_string("fluid")=="") then
+	local inv=meta:get_inventory()
-			local leftover=false
+	local fluidSlot=inv:get_stack("src",1)
-			local leftoverAddingSucceeded=false
+	local fluid=meta:get_string("fluid")
-			for _,item in ipairs(fuel.storageItems) do
+	local fluidAmount=meta:get_float("fluidAmount")
-				if item.name==fluidSlot:get_name() and item.leftover then
+
-					if inv:room_for_item("leftover",ItemStack(item.leftover)) then
+	if fluidSlot:is_empty() or fluidAmount>9000 then
-						inv:add_item("leftover",ItemStack(item.leftover))
+		return false
-						leftoverAddingSucceeded=true
+	end
-					end
+
-					leftover=true
+	local fuel=self.getFuelByItem(fluidSlot:get_name())
 	if fuel and (fuel.name==fluid or fluid=="") then
 		local leftover=false
 		local leftoverAddingSucceeded=false
 		for _,item in ipairs(fuel.storageItems) do
 			if item.name==fluidSlot:get_name() and item.leftover then
 				local leftoverItemstack=ItemStack(item.leftover)
 				if inv:room_for_item("dst",leftoverItemstack) then
 					inv:add_item("dst",leftoverItemstack)
 					leftoverAddingSucceeded=true
 				end
-			end
+				leftover=true
 			if not leftover or leftoverAddingSucceeded then
 				fluidSlot:take_item()
 				inv:set_stack("fluid",1,fluidSlot)
 				meta:set_string("fluid",fuel.name)
 				meta:set_float("fluidAmount",meta:get_float("fluidAmount")+1000)
 				shouldUpdateFormspec=true
 				shouldRerunTimer=false
 			end
 		end
 		if not leftover or leftoverAddingSucceeded then
 			fluidSlot:take_item()
 			inv:set_stack("src",1,fluidSlot)
 			meta:set_string("fluid",fuel.name)
 			meta:set_float("fluidAmount",fluidAmount+1000)
 			return true
 		end
 	end
-	if meta:get_float("fluidAmount")>=50 and not industrialtest.api.isFullyCharged(meta) then
+
-		meta:set_float("fluidAmount",meta:get_int("fluidAmount")-50*elapsed)
+	return false
-		local toAdd=math.ceil(industrialtest.api.getGeothermalGeneratorFuel(meta:get_string("fluid")).calorificValue*elapsed)
+end
 local function generate(self,pos,elapsed)
 	local meta=minetest.get_meta(pos)
 	local fluidAmount=meta:get_float("fluidAmount")
 	if fluidAmount>0 and not industrialtest.api.isFullyCharged(meta) then
 		local fluidUsed=math.min(fluidAmount,50)
 		meta:set_float("fluidAmount",fluidAmount-fluidUsed*elapsed)
 		local toAdd=math.ceil(self.getFuel(meta:get_string("fluid")).calorificValue*elapsed*fluidUsed/50)
 		industrialtest.api.addPower(meta,toAdd)
 		return true
 	end
 	return false
 end
 industrialtest.GeothermalGenerator=table.copy(industrialtest.ActivatedElectricMachine)
 industrialtest.internal.unpackTableInto(industrialtest.GeothermalGenerator,{
 	name="industrialtest:geothermal_generator",
 	description=S("Geothermal Generator"),
 	tiles={
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_geothermal_generator_front.png"
 	},
 	sounds="metal",
 	facedir=true,
 	storageLists={
 		"src",
 		"dst",
 		"charged"
 	},
 	active={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_geothermal_generator_front_active.png"
 		},
 		lightSource=10
 	},
 	powerLists={
 		{
 			list="charged",
 			direction="o"
 		}
 	},
 	requiresWrench=true,
 	hasPowerOutput=true,
 	capacity=7000,
 	flow=industrialtest.api.lvPowerFlow,
 	ioConfig="oooooo",
 	getFormspec=getFormspec,
 	getFuel=industrialtest.api.getGeothermalGeneratorFuel,
 	getFuelByItem=industrialtest.api.getGeothermalGeneratorFuelByItem
 })
 function industrialtest.GeothermalGenerator.onConstruct(self,pos)
 	onConstruct(pos)
 	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
 end
 function industrialtest.GeothermalGenerator.update(self,pos,elapsed,meta,inv)
 	local srcSlot=inv:get_stack("src",1)
 	local dstSlot=inv:get_stack("dst",1)
 	local shouldUpdateFormspec=takeFuelFromItem(self,pos)
 	return (not srcSlot:is_empty() and dstSlot:get_free_space()>0 and not industrialtest.api.isFluidStorageFull(meta)),shouldUpdateFormspec
 end
 function industrialtest.GeothermalGenerator.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	return math.min(allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count),industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count))
 end
 function industrialtest.GeothermalGenerator.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
 	return math.min(allowMetadataInventoryPut(pos,listname,index,stack,player),industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player))
 end
 function industrialtest.GeothermalGenerator.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	if toList=="src" and takeFuelFromItem(self,pos) then
 		self:trigger(pos)
 	end
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 end
 function industrialtest.GeothermalGenerator.onMetadataInventoryPut(self,pos,listname,index,stack)
 	if listname=="src" and takeFuelFromItem(self,pos) then
 		self:trigger(pos)
 	end
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
 end
 function industrialtest.GeothermalGenerator.shouldActivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcSlot=inv:get_stack("src",1)
 	local dstSlot=inv:get_stack("dst",1)
 	local fluidAmount=meta:get_float("fluidAmount")
 	return (fluidAmount>0 or (not srcSlot:is_empty() and dstSlot:get_free_space()>0)) and not industrialtest.api.isFullyCharged(meta)
 end
 function industrialtest.GeothermalGenerator.shouldDeactivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcSlot=inv:get_stack("src",1)
 	local dstSlot=inv:get_stack("dst",1)
 	local fluidAmount=meta:get_float("fluidAmount")
 	return (fluidAmount<=0 and (srcSlot:is_empty() or dstSlot:get_free_space()==0)) or industrialtest.api.isFullyCharged(meta)
 end
 function industrialtest.GeothermalGenerator.activeUpdate(self,pos,elapsed)
 	local shouldUpdateFormspec=false
 	if takeFuelFromItem(self,pos) then
 		shouldUpdateFormspec=true
 	end
 	if generate(self,pos,elapsed) then
 		shouldUpdateFormspec=true
 	end
 	return shouldUpdateFormspec
 end
 industrialtest.GeothermalGenerator:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:geothermal_generator",
 	recipe={
 		{industrialtest.elementKeys.glass,"industrialtest:empty_cell",industrialtest.elementKeys.glass},
 		{industrialtest.elementKeys.glass,"industrialtest:empty_cell",industrialtest.elementKeys.glass},
 		{"industrialtest:refined_iron_ingot","industrialtest:generator","industrialtest:refined_iron_ingot"}
 	}
 })
 industrialtest.WaterMill=table.copy(industrialtest.ElectricMachine)
 industrialtest.internal.unpackTableInto(industrialtest.WaterMill,{
 	name="industrialtest:water_mill",
 	description=S("Water Mill"),
 	tiles={
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_water_mill_side.png",
 		"industrialtest_machine_block.png^industrialtest_water_mill_side.png",
 		"industrialtest_machine_block.png^industrialtest_water_mill_side.png",
 		"industrialtest_machine_block.png^industrialtest_water_mill_side.png"
 	},
 	sounds="metal",
 	storageLists={
 		"src",
 		"dst",
 		"charged"
 	},
 	powerLists={
 		{
 			list="charged",
 			direction="o"
 		}
 	},
 	requiresWrench=true,
 	hasPowerOutput=true,
 	capacity=7000,
 	flow=industrialtest.api.lvPowerFlow,
 	ioConfig="oooooo",
 	getFormspec=getFormspec,
 	getFuel=industrialtest.api.getWaterMillFuel,
 	getFuelByItem=industrialtest.api.getWaterMillFuelByItem
 })
 function industrialtest.WaterMill.onConstruct(self,pos)
 	onConstruct(pos)
 	industrialtest.ElectricMachine.onConstruct(self,pos)
 end
 function industrialtest.WaterMill.canUpdate(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcSlot=inv:get_stack("src",1)
 	local dstSlot=inv:get_stack("dst",1)
 	local fluidAmount=meta:get_float("fluidAmount")
 	return (fluidAmount>0 or (not srcSlot:is_empty() and dstSlot:get_free_space()>0)) and not industrialtest.api.isFullyCharged(meta)
 end
 function industrialtest.WaterMill.update(self,pos,elapsed)
 	local shouldUpdateFormspec=false
 	local shouldRerunTimer=false
 	if takeFuelFromItem(self,pos) then
 		shouldUpdateFormspec=true
 		shouldRerunTimer=true
 	else
 		minetest.swap_node(pos,{
 			name="industrialtest:"..config.name,
 			param2=minetest.get_node(pos).param2
 		})
 		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
-	if chargedSlot:get_count()>0 and meta:get_int("industrialtest.powerAmount")>0 then
+
-		if industrialtest.api.transferPowerToItem(meta,chargedSlot,industrialtest.api.lvPowerFlow)>0 then
+	if generate(self,pos,elapsed) then
 			inv:set_stack("charged",1,chargedSlot)
 			shouldUpdateFormspec=true
 			shouldRerunTimer=true
 		end
 	end
 	if flowTransferred then
 		shouldUpdateFormspec=true
 		shouldRerunTimer=true
 	end
 	return shouldRerunTimer,shouldUpdateFormspec
 end
-local function registerFluidGenerator(config)
+function industrialtest.WaterMill.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	local definition={
+	return math.min(allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count),industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count))
 		name=config.name,
 		displayName=config.displayName,
 		getFormspec=function(pos)
 			return fluidGenerator.getFormspec(pos,config)
 		end,
 		capacity=7000,
 		flow=industrialtest.api.lvPowerFlow,
 		ioConfig="oooooo",
 		requiresWrench=true,
 		registerActiveVariant=config.registerActiveVariant,
 		powerSlots={"charged"},
 		storageSlots={"fluid","fluidLeftover"},
 		sounds="metal",
 		groups={
 			_industrialtest_hasPowerOutput=1
 		},
 		customKeys={
 			tiles={
 				"industrialtest_machine_block.png"..(config.customTopTexture and "^"..config.customTopTexture or ""),
 				"industrialtest_machine_block.png"..(config.customBottomTexture and "^"..config.customBottomTexture or ""),
 				"industrialtest_machine_block.png"..(config.customRightTexture and "^"..config.customRightTexture or ""),
 				"industrialtest_machine_block.png"..(config.customLeftTexture and "^"..config.customLeftTexture or ""),
 				"industrialtest_machine_block.png"..(config.customBackTexture and "^"..config.customBackTexture or ""),
 				"industrialtest_machine_block.png"..(config.customFrontTexture and "^"..config.customFrontTexture or "")
 			},
 			paramtype2="facedir",
 			legacy_facedir_simple=true
 		},
 		onConstruct=fluidGenerator.onConstruct,
 		onTimer=function(pos,elapsed,meta,inv)
 			return fluidGenerator.onTimer(pos,elapsed,meta,inv,config)
 		end,
 		onMetadataInventoryPut=fluidGenerator.metadataChange,			
 		onMetadataInventoryMove=fluidGenerator.metadataChange
 	}
 	if config.registerActiveVariant then
 		definition.activeCustomKeys={
 			tiles={
 				"industrialtest_machine_block.png"..(config.customTopTexture and "^"..config.customTopTextureActive or ""),
 				"industrialtest_machine_block.png"..(config.customBottomTexture and "^"..config.customBottomTextureActive or ""),
 				"industrialtest_machine_block.png"..(config.customRightTexture and "^"..config.customRightTextureActive or ""),
 				"industrialtest_machine_block.png"..(config.customLeftTexture and "^"..config.customLeftTextureActive or ""),
 				"industrialtest_machine_block.png"..(config.customBackTexture and "^"..config.customBackTextureActive or ""),
 				"industrialtest_machine_block.png"..(config.customFrontTexture and "^"..config.customFrontTextureActive or "")
 			},
 			light_source=8
 		}
 		definition.activeOnTimer=function(pos,elapsed,meta,inv)
 			return fluidGenerator.activeOnTimer(pos,elapsed,meta,inv,config)
 		end
 	end
 	industrialtest.internal.registerMachine(definition)
 end
-registerFluidGenerator({
+function industrialtest.WaterMill.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
-	name="geothermal_generator",
+	return math.min(allowMetadataInventoryPut(pos,listname,index,stack,player),industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player))
-	displayName=S("Geothermal Generator"),
+end
-	customFrontTexture="industrialtest_geothermal_generator_front.png",
+
-	customFrontTextureActive="industrialtest_geothermal_generator_front_active.png",
+function industrialtest.WaterMill.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	getFuel=industrialtest.api.getGeothermalGeneratorFuel,
+	if toList=="src" and takeFuelFromItem(self,pos) then
-	getFuelByItem=industrialtest.api.getGeothermalGeneratorFuelByItem,
+		self:trigger(pos)
-	registerActiveVariant=true,
+	end
-	reactsToNeighbouringNodes=false
+	industrialtest.ElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-})
+end
 function industrialtest.WaterMill.onMetadataInventoryPut(self,pos,listname,index,stack)
 	if listname=="src" and takeFuelFromItem(self,pos) then
 		self:trigger(pos)
 	end
 	industrialtest.ElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
 end
 function industrialtest.WaterMill.action(self,pos)
 	local meta=minetest.get_meta(pos)
 	local powerToAdd=0
 	local neighbourPositions={
 		vector.offset(pos,-1,0,0),
 		vector.offset(pos,1,0,0),
 		vector.offset(pos,0,-1,0),
 		vector.offset(pos,0,1,0),
 		vector.offset(pos,0,0,-1),
 		vector.offset(pos,0,0,1)
 	}
 	for _,value in ipairs(neighbourPositions) do
 		local node=minetest.get_node_or_nil(value)
 		if node then
 			local fuel=industrialtest.api.getWaterMillFuel(node.name)
 			if fuel then
 				powerToAdd=powerToAdd+fuel.calorificValue*0.2
 			end
 		end
 	end
 	if industrialtest.api.addPower(meta,powerToAdd)>0 then
 		self:updateFormspec(pos)
 		self:trigger(pos)
 	end
 end
 industrialtest.WaterMill:register()
 registerFluidGenerator({
 	name="water_mill",
 	displayName=S("Water Mill"),
 	customLeftTexture="industrialtest_water_mill_side.png",
 	customRightTexture="industrialtest_water_mill_side.png",
 	customFrontTexture="industrialtest_water_mill_side.png",
 	customBackTexture="industrialtest_water_mill_side.png",
 	getFuel=industrialtest.api.getWaterMillFuel,
 	getFuelByItem=industrialtest.api.getWaterMillFuelByItem,
 	registerActiveVariant=false
 })
 local neighbors={}
 for key,_ in pairs(industrialtest.api.waterMillFuels) do
 	table.insert(neighbors,key)
@@ -271,37 +368,8 @@ minetest.register_abm({
 	neighbors=neighbors,
 	interval=industrialtest.updateDelay,
 	chance=1,
-	action=function(pos,node)
+	action=function(pos)
-		local meta=minetest.get_meta(pos)
+		industrialtest.WaterMill:action(pos)
 		local inv=meta:get_inventory()
 		local chargedSlot=inv:get_stack("charged",1)
 		local powerToAdd=0
 		local neighbourPositions={
 			vector.offset(pos,-1,0,0),
 			vector.offset(pos,1,0,0),
 			vector.offset(pos,0,-1,0),
 			vector.offset(pos,0,1,0),
 			vector.offset(pos,0,0,-1),
 			vector.offset(pos,0,0,1)
 		}
 		for _,value in ipairs(neighbourPositions) do
 			local node=minetest.get_node_or_nil(value)
 			if node then
 				local fuel=industrialtest.api.getWaterMillFuel(node.name)
 				if fuel then
 					powerToAdd=powerToAdd+fuel.calorificValue*0.2
 				end
 			end
 		end
 		if industrialtest.api.addPower(meta,powerToAdd)>0 then
 			local def=minetest.registered_nodes[node.name]
 			def._industrialtest_updateFormspec(meta)
 		end
 		if chargedSlot:get_count()>0 and meta:get_int("industrialtest.powerAmount")>0 then
 			if industrialtest.api.transferPowerToItem(meta,chargedSlot,industrialtest.api.lvPowerFlow)>0 then
 				inv:set_stack("charged",1,chargedSlot)
 			end
 		end
 	end
 })
--- a/machines/generator.lua
+++ b/machines/generator.lua
@@ -15,169 +15,151 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-local generator={}
+industrialtest.Generator=table.copy(industrialtest.ActivatedElectricMachine)
-
+industrialtest.internal.unpackTableInto(industrialtest.Generator,{
-generator.getFormspec=function(pos)
+	name="industrialtest:generator",
-	local meta=minetest.get_meta(pos)
+	description=S("Generator"),
-	local fuelPercent=meta:get_int("fuelTime")/meta:get_int("maxFuelTime")*100
+		tiles={
-	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
+		"industrialtest_machine_block.png",
-	local formspec
+		"industrialtest_machine_block.png",
-	if industrialtest.mtgAvailable then
+		"industrialtest_machine_block.png",
-		formspec={
+		"industrialtest_machine_block.png",
-			"list[context;charged;4.9,1.8;1,1]",
+		"industrialtest_machine_block.png",
-			"listring[context;charged]",
+		"industrialtest_machine_block.png^industrialtest_iron_furnace_front.png"
-			(fuelPercent>0 and "image[4.9,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
+	},
-			 or "image[4.9,2.8;1,1;default_furnace_fire_bg.png]"),
+	sounds="metal",
-			"list[context;fuel;4.9,3.9;1,1]",
+	facedir=true,
-			"listring[context;fuel]",
+	storageLists={
-			"box[9,1;0.3,4.8;#202020]",
+		"src",
-			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or "")
+		"charged"
-		}
+	},
-	elseif industrialtest.mclAvailable then
+	active={
-		formspec={
+		tiles={
-			"list[context;charged;4.7,1.8;1,1]",
+			"industrialtest_machine_block.png",
-			mcl_formspec.get_itemslot_bg(4.7,1.8,1,1),
+			"industrialtest_machine_block.png",
-			"listring[context;charged]",
+			"industrialtest_machine_block.png",
-			(fuelPercent>0 and "image[4.7,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
+			"industrialtest_machine_block.png",
-			 or "image[4.7,2.8;1,1;default_furnace_fire_bg.png]"),
+			"industrialtest_machine_block.png",
-			"list[context;fuel;4.7,3.9;1,1]",
+			"industrialtest_machine_block.png^industrialtest_iron_furnace_front_active.png"
-			mcl_formspec.get_itemslot_bg(4.7,3.9,1,1),
+		},
-			"listring[context;fuel]",
+		lightSource=8
-			"box[9,1;0.3,4.8;#202020]",
+	},
 			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or "")
 		}
 	end
 	return table.concat(formspec,"")
 end
 generator.onConstruct=function(pos,meta,inv)
 	inv:set_size("charged",1)
 	inv:set_size("fuel",1)
 	meta:set_int("fuelTime",0)
 	meta:set_int("maxFuelTime",1)
 end
 generator.onTimer=function(pos,elapsed,meta,inv)
 	local powerFlow=meta:get_int("industrialtest.powerFlow")
 	local chargedSlot=inv:get_stack("charged",1)
 	local fuelSlot=inv:get_stack("fuel",1)
 	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
 	local shouldUpdateFormspec=flowTransferred
 	local shouldRerunTimer=(afterFlow and meta:get_int("industrialtest.powerAmount")>0)
 	if chargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(chargedSlot:get_meta()) and meta:get_int("industrialtest.powerAmount")>0 then
 		industrialtest.api.transferPowerToItem(meta,chargedSlot,powerFlow)
 		inv:set_stack("charged",1,chargedSlot)
 		shouldUpdateFormspec=true
 		shouldRerunTimer=true
 	end
 	if fuelSlot:get_count()>0 and meta:get_int("fuelTime")<=0 and not industrialtest.api.isFullyCharged(meta) then
 		local output,after=minetest.get_craft_result({
 			method="fuel",
 			width=1,
 			items={fuelSlot}
 		})
 		if output.time>0 then
 			meta:set_int("fuelTime",output.time)
 			meta:set_int("maxFuelTime",output.time)
 			inv:set_stack("fuel",1,after.items[1])
 			minetest.swap_node(pos,{
 				name="industrialtest:generator_active",
 				param2=minetest.get_node(pos).param2
 			})
 			minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 		end
 	end
 	return shouldRerunTimer,shouldUpdateFormspec
 end
 generator.activeOnTimer=function(pos,elapsed,meta,inv)
 	local chargedSlot=inv:get_stack("charged",1)
 	local fuelSlot=inv:get_stack("fuel",1)
 	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
 	local shouldUpdateFormspec=flowTransferred
 	local shouldRerunTimer=(afterFlow and meta:get_int("industrialtest.powerAmount")>0)
 	if chargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(chargedSlot:get_meta()) and meta:get_int("industrialtest.powerAmount")>0 then
 		industrialtest.api.transferPowerToItem(meta,chargedSlot,chargedSlot:get_meta():get_int("industrialtest.powerFlow"))
 		inv:set_stack("charged",1,chargedSlot)
 		shouldUpdateFormspec=true
 		shouldRerunTimer=true
 	end
 	if fuelSlot:get_count()>0 and meta:get_int("fuelTime")<=0 and not industrialtest.api.isFullyCharged(meta) then
 		local output,after=minetest.get_craft_result({
 			method="fuel",
 			width=1,
 			items={fuelSlot}
 		})
 		if output.time>0 then
 			meta:set_int("fuelTime",output.time)
 			meta:set_int("maxFuelTime",output.time)
 			inv:set_stack("fuel",1,after.items[1])
 		end
 	end
 	if meta:get_int("fuelTime")>0 then
 		meta:set_int("fuelTime",meta:get_int("fuelTime")-elapsed)
 		industrialtest.api.addPower(meta,200)
 		shouldUpdateFormspec=true
 		shouldRerunTimer=true
 	else
 		minetest.swap_node(pos,{
 			name="industrialtest:generator",
 			param2=minetest.get_node(pos).param2
 		})
 	end
 	return shouldRerunTimer,shouldUpdateFormspec
 end
 generator.metadataChange=function(pos)
 	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 end
 industrialtest.internal.registerMachine({
 	name="generator",
 	displayName=S("Generator"),
 	getFormspec=generator.getFormspec,
 	capacity=7000,
 	flow=industrialtest.api.lvPowerFlow,
 	ioConfig="oooooo",
-	registerActiveVariant=true,
+	hasPowerOutput=true,
-	powerSlots={"charged"},
+	powerLists={
-	storageSlots={"charged","fuel"},
+		{
-	sounds="metal",
+			list="charged",
-	groups={
+			direction="o"
-		_industrialtest_hasPowerOutput=1
+		}
-	},
+	}
 	customKeys={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_iron_furnace_front.png",
 			"industrialtest_machine_block.png"
 		},
 		paramtype2="facedir",
 		legacy_facedir_simple=true
 	},
 	activeCustomKeys={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_iron_furnace_front_active.png",
 			"industrialtest_machine_block.png"
 		},
 		light_source=8
 	},
 	onConstruct=generator.onConstruct,
 	onTimer=generator.onTimer,
 	activeOnTimer=generator.activeOnTimer,
 	onMetadataInventoryPut=generator.metadataChange,
 	onMetadataInventoryMove=generator.metadataChange
 })
 function industrialtest.Generator.onConstruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	inv:set_size("charged",1)
 	inv:set_size("src",1)
 	meta:set_float("fuelTime",0)
 	meta:set_float("maxFuelTime",1)
 	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
 end
 function industrialtest.Generator.getFormspec(self,pos)
 	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	local fuelPercent=meta:get_float("fuelTime")/meta:get_float("maxFuelTime")*100
 	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
 	local formspec={
 		"list[context;charged;4.7,1.8;1,1]",
 		industrialtest.internal.getItemSlotBg(4.7,1.8,1,1),
 		(fuelPercent>0 and "image[4.7,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
 		 or "image[4.7,2.8;1,1;default_furnace_fire_bg.png]"),
 		"list[context;src;4.7,3.9;1,1]",
 		industrialtest.internal.getItemSlotBg(4.7,3.9,1,1),
 		self.createPowerIndicatorWidget(charged,9,1),
 		"listring[context;src]"
 	}
 	return parentFormspec..table.concat(formspec,"")
 end
 function industrialtest.Generator.onMetadataInventoryPut(self,pos,listname,index,stack)
 	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
 end
 function industrialtest.Generator.activeUpdate(self,pos,elapsed,meta,inv)
 	local chargedSlot=inv:get_stack("charged",1)
 	local fuelSlot=inv:get_stack("src",1)
 	local shouldUpdateFormspec=false
 	if fuelSlot:get_count()>0 and meta:get_float("fuelTime")<=0 and not industrialtest.api.isFullyCharged(meta) then
 		local output,after=minetest.get_craft_result({
 			method="fuel",
 			width=1,
 			items={fuelSlot}
 		})
 		if output.time>0 then
 			meta:set_float("fuelTime",output.time)
 			meta:set_float("maxFuelTime",output.time)
 			inv:set_stack("src",1,after.items[1])
 		end
 	end
 	if meta:get_float("fuelTime")>0 then
 		meta:set_float("fuelTime",meta:get_float("fuelTime")-elapsed)
 		industrialtest.api.addPower(meta,200)
 		shouldUpdateFormspec=true
 	end
 	return shouldUpdateFormspec
 end
 function industrialtest.Generator.shouldActivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local fuelSlot=inv:get_stack("src",1)
 	if fuelSlot:get_count()>0 and not industrialtest.api.isFullyCharged(meta) then
 		local output,after=minetest.get_craft_result({
 			method="fuel",
 			width=1,
 			items={fuelSlot}
 		})
 		if output.time>0 then
 			return true
 		end
 	end
 	return false
 end
 function industrialtest.Generator.shouldDeactivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	if meta:get_float("fuelTime")>0 then
 		return false
 	end
 	local inv=meta:get_inventory()
 	local fuelSlot=inv:get_stack("src",1)
 	if fuelSlot:get_count()>0 and not industrialtest.api.isFullyCharged(meta) then
 		local output,after=minetest.get_craft_result({
 			method="fuel",
 			width=1,
 			items={fuelSlot}
 		})
 		if output.time>0 then
 			return false
 		end
 	end
 	return true
 end
 industrialtest.Generator:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:generator",
--- a/machines/induction_furnace.lua
+++ b/machines/induction_furnace.lua
@@ -0,0 +1,294 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
 industrialtest.InductionFurnace=table.copy(industrialtest.ActivatedElectricMachine)
 industrialtest.internal.unpackTableInto(industrialtest.InductionFurnace,{
 	name="industrialtest:induction_furnace",
 	description=S("Induction Furnace"),
 	tiles={
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png^industrialtest_electric_furnace_front.png"
 	},
 	sounds="metal",
 	requiresWrench=true,
 	facedir=true,
 	storageLists={
 		"src",
 		"dst",
 		"upgrades",
 		"powerStorage"
 	},
 	powerLists={
 		{
 			list="powerStorage",
 			direction="i"
 		}
 	},
 	active={
 		tiles={
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png^industrialtest_electric_furnace_front_active.png"
 		}
 	},
 	capacity=industrialtest.api.mvPowerFlow*2,
 	flow=industrialtest.api.mvPowerFlow,
 	hasPowerInput=true,
 	ioConfig="iiiiii",
 	_opPower=60,
 	_efficiency=0.5
 })
 function industrialtest.InductionFurnace.onConstruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	inv:set_size("src",2)
 	inv:set_size("dst",2)
 	inv:set_size("powerStorage",1)
 	inv:set_size("upgrades",4)
 	meta:set_int("heat",0)
 	meta:set_float("srcTime",0)
 	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
 end
 function industrialtest.InductionFurnace.getFormspec(self,pos)
 	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
 	local maxSrcTime=meta:get_float("maxSrcTime")
 	local srcPercent=maxSrcTime>0 and meta:get_float("srcTime")/maxSrcTime*100 or 0
 	local heat=meta:get_int("heat")
 	local formspec={
 		"list[context;src;3.7,1.8;2,1]",
 		industrialtest.internal.getItemSlotBg(3.7,1.8,2,1),
 		(powerPercent>0 and "image[3.7,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
 		 or "image[3.7,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
 		"list[context;powerStorage;3.7,3.9;1,1]",
 		industrialtest.internal.getItemSlotBg(3.7,3.9,1,1),
 		(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
 		 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
 		"list[context;dst;6,2.8;2,1;]",
 		industrialtest.internal.getItemSlotBg(6,2.8,2,1),
 		"list[context;upgrades;9,0.9;1,4]",
 		industrialtest.internal.getItemSlotBg(9,0.9,1,4),
 		"label[0.5,2.8;"..minetest.formspec_escape(S("Heat: @1 %",heat)).."]",
 		"listring[context;src]",
 		"listring[context;dst]"
    }
 	return parentFormspec..table.concat(formspec,"")
 end
 function industrialtest.InductionFurnace.update(self,pos,elapsed,meta,inv)
 	local srcList=inv:get_list("src")
 	local heat=meta:get_int("heat")
 	local shouldRerunTimer=false
 	local shouldUpdateFormspec=false
 	if heat>0 then
 		meta:set_int("heat",math.max(heat-math.max(2*elapsed,1),0))
 		shouldRerunTimer=true
 		shouldUpdateFormspec=true
 	end
 	return shouldRerunTimer,shouldUpdateFormspec
 end
 function industrialtest.InductionFurnace.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	if toList=="dst" then
 		return 0
 	end
 	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 end
 function industrialtest.InductionFurnace.allowMetadataInventoryPut(self,pos,listname,index,stack)
 	if listname=="dst" then
 		return 0
 	end
 	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack)
 end
 function industrialtest.InductionFurnace.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	if fromList=="src" or toList=="src" then
 		self:calculateMaxSrcTime(pos)
 	end
 	if fromList=="src" and self.isInputEmpty(pos) then
 		local meta=minetest.get_meta(pos)
 		meta:set_float("srcTime",-1)
 		meta:set_float("maxSrcTime",0)
 		self:updateFormspec(pos)
 	elseif toList=="src" or (fromList=="dst" and not self.isOutputFull(pos)) then
 		self:triggerIfNeeded(pos)
 	end
 end
 function industrialtest.InductionFurnace.onMetadataInventoryPut(self,pos,listname,index,stack,player)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack,player)
 	if listname=="src" then
 		self:calculateMaxSrcTime(pos)
 		self:triggerIfNeeded(pos)
 	end
 end
 function industrialtest.InductionFurnace.onMetadataInventoryTake(self,pos,listname,index,stack)
 	if listname=="src" then
 		self:calculateMaxSrcTime(pos)
 	elseif listname=="dst" and not self.isOutputFull(pos) then
 		self:triggerIfNeeded(pos)
 	end
 end
 function industrialtest.InductionFurnace.shouldActivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcList=inv:get_list("src")
 	for _,slot in ipairs(srcList) do
 		if not slot:is_empty() then
 			local result,after=minetest.get_craft_result({
 				method="cooking",
 				width=1,
 				items={slot}
 			})
 			if result.time>0 and inv:room_for_item("dst",result.item) then
 				return meta:get_int("industrialtest.powerAmount")>=self._opPower
 			end
 		end
 	end
 	return false
 end
 function industrialtest.InductionFurnace.shouldDeactivate(self,pos)
 	return not self:shouldActivate(pos)
 end
 function industrialtest.InductionFurnace.activeUpdate(self,pos,elapsed,meta,inv)
 	local srcList=inv:get_list("src")
 	local powerAmount=meta:get_int("industrialtest.powerAmount")
 	local srcTime=meta:get_float("srcTime")
 	local maxSrcTime=meta:get_float("maxSrcTime")
 	local heat=meta:get_int("heat")
 	local speed=industrialtest.api.getMachineSpeed(meta)
 	local requiredPower=elapsed*self._opPower*speed
 	local results={}
 	for _,slot in ipairs(srcList) do
 		if slot:is_empty() then
 			table.insert(results,false)
 		else
 			local result,after=minetest.get_craft_result({
 				method="cooking",
 				width=1,
 				items={slot}
 			})
 			if result.time>0 and inv:room_for_item("dst",result.item) then
 				table.insert(results,result.item)
 			else
 				table.insert(results,false)
 			end
 		end
 	end
 	srcTime=srcTime+elapsed*(1+heat/200)
 	if srcTime>=maxSrcTime then
 		for i,result in ipairs(results) do
 			if result then
 				local multiplier=math.min(srcList[i]:get_count(),speed)
 				local prevCount=result:get_count()
 				result:set_count(result:get_count()*multiplier)
 				local leftover=inv:add_item("dst",result)
 				srcList[i]:take_item(multiplier-leftover:get_count()/prevCount)
 				inv:set_stack("src",i,srcList[i])
 			end
 		end
 		srcTime=0
 	end
 	meta:set_float("srcTime",srcTime)
 	if heat<100 then
 		meta:set_int("heat",math.min(100,heat+speed))
 	end
 	industrialtest.api.addPower(meta,-requiredPower)
 	return true
 end
 function industrialtest.InductionFurnace.calculateMaxSrcTime(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcList=inv:get_list("src")
 	local maxSrcTime=0
 	for _,slot in ipairs(srcList) do
 		local result,_=minetest.get_craft_result({
 			method="cooking",
 			width=1,
 			items={slot}
 		})
 		maxSrcTime=math.max(maxSrcTime,result.time*self._efficiency)
 	end
 	meta:set_float("maxSrcTime",maxSrcTime)
 end
 function industrialtest.InductionFurnace.isInputEmpty(pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcList=inv:get_list("src")
 	for _,slot in ipairs(srcList) do
 		if not slot:is_empty() then
 			return false
 		end
 	end
 	return true
 end
 function industrialtest.InductionFurnace.isOutputFull(pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local dstList=inv:get_list("dst")
 	for _,slot in ipairs(dstList) do
 		if slot:get_free_space()>0 then
 			return false
 		end
 	end
 	return true
 end
 industrialtest.InductionFurnace:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:induction_furnace",
 	recipe={
 		{industrialtest.elementKeys.copperIngot,industrialtest.elementKeys.copperIngot,industrialtest.elementKeys.copperIngot},
 		{industrialtest.elementKeys.copperIngot,"industrialtest:electric_furnace",industrialtest.elementKeys.copperIngot},
 		{industrialtest.elementKeys.copperIngot,"industrialtest:advanced_machine_block",industrialtest.elementKeys.copperIngot}
 	}
 })
--- a/machines/iron_furnace.lua
+++ b/machines/iron_furnace.lua
@@ -15,115 +15,153 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-local ironFurnace={}
+industrialtest.IronFurnace=table.copy(industrialtest.ActivatedMachine)
 industrialtest.internal.unpackTableInto(industrialtest.IronFurnace,{
 	name="industrialtest:iron_furnace",
 	description=S("Iron Furnace"),
 	tiles={
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_iron_furnace_front.png"
 	},
 	active={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_iron_furnace_front_active.png"
 		},
 		lightSource=8
 	},
 	facedir=true,
 	storageLists={
 		"src",
 		"fuel",
 		"dst"
 	}
 })
-ironFurnace.getFormspec=function(fuelPercent,srcPercent)
+function industrialtest.IronFurnace.onConstruct(self,pos)
 	local formspec
 	if industrialtest.mtgAvailable then
 		formspec={
 			"formspec_version[4]",
 			"size[10.8,12]",
 			"label[0.5,0.5;"..S("Iron Furnace").."]",
 			"list[context;src;3.4,1.8;1,1]",
 			"listring[context;src]",
 			(fuelPercent>0 and "image[3.4,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
 			 or "image[3.4,2.8;1,1;default_furnace_fire_bg.png]"),
 			"list[context;fuel;3.4,3.9;1,1]",
 			"listring[context;fuel]",
 			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
 			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
 			"list[context;dst;6.4,2.8;1,1]",
 			"listring[context;dst]",
 			"list[current_player;main;0.5,6.25;8,1]",
 			"list[current_player;main;0.5,7.5;8,3;8]"
 		}
 	elseif industrialtest.mclAvailable then
 		formspec={
 			"size[10.04,12]",
 			"label[0.25,0.25;"..S("Iron Furnace").."]",
 			"list[context;src;3.4,1.8;1,1]",
 			mcl_formspec.get_itemslot_bg(3.4,1.8,1,1),
 			"listring[context;src]",
 			(fuelPercent>0 and "image[3.4,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
 			 or "image[3.4,2.8;1,1;default_furnace_fire_bg.png]"),
 			"list[context;fuel;3.4,3.9;1,1]",
 			mcl_formspec.get_itemslot_bg(3.4,3.9,1,1),
 			"listring[context;fuel]",
 			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
 			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
 			"list[context;dst;6.4,2.8;1,1]",
 			mcl_formspec.get_itemslot_bg(6.4,2.8,1,1),
 			"listring[context;dst]",
 			"list[current_player;main;0.5,7;9,3;9]",
 			mcl_formspec.get_itemslot_bg(0.5,7,9,3),
 			"list[current_player;main;0.5,10.24;9,1]",
 			mcl_formspec.get_itemslot_bg(0.5,10.24,9,1)
 		}
 	end
 	return table.concat(formspec,"")
 end
 ironFurnace.onConstruct=function(pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	inv:set_size("src",1)
 	inv:set_size("dst",1)
 	inv:set_size("fuel",1)
 	meta:set_string("formspec",ironFurnace.getFormspec(0,0))
 	meta:set_float("fuelTime",0)
 	meta:set_float("maxFuelTime",1)
-	meta:set_float("srcTime",-1)
+	meta:set_float("srcTime",0)
 	meta:set_float("maxSrcTime",0)
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	industrialtest.ActivatedMachine.onConstruct(self,pos)
 end
-ironFurnace.onTimer=function(pos,elapsed)
+function industrialtest.IronFurnace.getFormspec(self,pos)
 	local parentFormspec=industrialtest.ActivatedMachine.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
+	local fuelPercent=meta:get_float("fuelTime")/meta:get_float("maxFuelTime")*100
-	local srcSlot=inv:get_stack("src",1)
+	local maxSrcTime=meta:get_float("maxSrcTime")
-	local fuelSlot=inv:get_stack("fuel",1)
+	local srcPercent=meta:get_float("srcTime")/(maxSrcTime>0 and maxSrcTime or 0)*100
-	local shouldUpdateFormspec=false
+	local formspec
-	local shouldRerunTimer=false
+	if industrialtest.mtgAvailable then
 		formspec={
 			"list[context;src;3.4,1.8;1,1]",
 			(fuelPercent>0 and "image[3.4,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
 			 or "image[3.4,2.8;1,1;default_furnace_fire_bg.png]"),
 			"list[context;fuel;3.4,3.9;1,1]",
 			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
 			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
 			"list[context;dst;6.4,2.8;1,1]",
 			"listring[context;src]",
 			"listring[context;dst]"
 		}
 	elseif industrialtest.mclAvailable then
 		formspec={
 			"list[context;src;3.4,1.8;1,1]",
 			mcl_formspec.get_itemslot_bg(3.4,1.8,1,1),
 			(fuelPercent>0 and "image[3.4,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
 			 or "image[3.4,2.8;1,1;default_furnace_fire_bg.png]"),
 			"list[context;fuel;3.4,3.9;1,1]",
 			mcl_formspec.get_itemslot_bg(3.4,3.9,1,1),
 			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
 			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
 			"list[context;dst;6.4,2.8;1,1]",
 			mcl_formspec.get_itemslot_bg(6.4,2.8,1,1),
 			"listring[context;src]",
 			"listring[context;dst]"
 		}
 	end
 	return parentFormspec..table.concat(formspec,"")
 end
-	if fuelSlot:get_count()>0 and meta:get_float("fuelTime")<=0 then
+function industrialtest.IronFurnace.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-		local output,after=minetest.get_craft_result({
+	if toList=="dst" then
-			method="cooking",
+		return 0
-			width=1,
+	end
-			items={srcSlot}
+	return industrialtest.ActivatedMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-		})
+end
-		if output.time>0 and inv:room_for_item("dst",output.item) then
+
-			output,after=minetest.get_craft_result({
+function industrialtest.IronFurnace.allowMetadataInventoryPut(self,pos,listname,index,stack)
-				method="fuel",
+	if listname=="dst" then
-				width=1,
+		return 0
-				items={fuelSlot}
+	elseif listname=="src" then
-			})
+		local meta=minetest.get_meta(pos)
-			if output.time>0 then
+		local inv=meta:get_inventory()
-				meta:set_float("fuelTime",output.time)
+		local srcSlot=inv:get_stack("src",1)
-				meta:set_float("maxFuelTime",output.time)
+		if srcSlot:get_name()~=stack:get_name() then
-				inv:set_stack("fuel",1,after.items[1])
+			meta:set_float("srcTime",0)
-				minetest.swap_node(pos,{
+			meta:set_float("maxSrcTime",0)
 					name="industrialtest:iron_furnace_active",
 					param2=minetest.get_node(pos).param2
 				})
 				minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 			end
 		end
 	end
-
+	return industrialtest.ActivatedMachine.allowMetadataInventoryPut(self,pos,listname,index,stack)
 	if shouldUpdateFormspec then
 		meta:set_string("formspec",ironFurnace.getFormspec(meta:get_float("fuelTime")/meta:get_float("maxFuelTime")*100,meta:get_float("srcTime")/meta:get_float("maxSrcTime")*100))
 	end
 	return shouldRerunTimer
 end
-ironFurnace.activeOnTimer=function(pos,elapsed)
+function industrialtest.IronFurnace.allowMetadataInventoryTake(self,pos,listname,index,stack)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcSlot=inv:get_stack("src",1)
 	local dstSlot=inv:get_stack("dst",1)
 	if listname=="src" and stack:get_count()==srcSlot:get_count() then
 		meta:set_float("srcTime",0)
 		meta:set_float("maxSrcTime",0)
 		if meta:get_float("maxFuelTime")>0 then
 			self:updateFormspec(pos)
 		end
 	elseif listname=="dst" and dstSlot:get_free_space()==0 then
 		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
 	return industrialtest.ActivatedMachine.allowMetadataInventoryTake(self,pos,listname,index,stack)
 end
 function industrialtest.IronFurnace.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcSlot=inv:get_stack("src",1)
 	local dstSlot=inv:get_stack("dst",1)
 	if fromList=="src" and count==srcSlot:get_count() then
 		meta:set_float("srcTime",-1)
 		meta:set_float("maxSrcTime",0)
 		if meta:get_float("maxFuelTime")>0 then
 			self:updateFormspec(pos)
 		end
 	elseif fromList=="dst" and dstSlot:get_free_space()==0 then
 		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
 	industrialtest.ActivatedMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 end
 function industrialtest.IronFurnace.onMetadataInventoryPut(self,pos,listname,index,stack)
 	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	industrialtest.ActivatedMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
 end
 function industrialtest.IronFurnace.activeUpdate(self,pos,elapsed,meta,inv)
 	local srcSlot=inv:get_stack("src",1)
 	local fuelSlot=inv:get_stack("fuel",1)
 	local shouldUpdateFormspec=false
 	local shouldRerunTimer=false
 	if fuelSlot:get_count()>0 and meta:get_float("fuelTime")<=0 then
 		local output,after=minetest.get_craft_result({
@@ -146,9 +184,9 @@ ironFurnace.activeOnTimer=function(pos,elapsed)
 	end
 	if srcSlot:get_count()>0 and meta:get_float("maxSrcTime")<=0 and meta:get_float("fuelTime")>0 then
 		local output,after=minetest.get_craft_result({
-				method="cooking",
+			method="cooking",
-				width=1,
+			width=1,
-				items={srcSlot}
+			items={srcSlot}
 		})
 		if output.time>0 and inv:room_for_item("dst",output.item) then
 			meta:set_float("srcTime",0)
@@ -156,35 +194,17 @@ ironFurnace.activeOnTimer=function(pos,elapsed)
 		end
 	end
 	if meta:get_float("fuelTime")>0 then
 		if meta:get_float("maxSrcTime")>0 then
 			meta:set_float("srcTime",meta:get_float("srcTime")+elapsed)
 		end
 		meta:set_float("fuelTime",meta:get_float("fuelTime")-elapsed)
 		shouldUpdateFormspec=true
 		shouldRerunTimer=true
 	end
 	if meta:get_float("maxSrcTime")>0 then
 		if meta:get_float("fuelTime")>0 then
 			meta:set_float("srcTime",meta:get_float("srcTime")+elapsed)
 		else
 			meta:set_float("srcTime",0)
 			minetest.swap_node(pos,{
 				name="industrialtest:iron_furnace",
 				param2=minetest.get_node(pos).param2
 			})
 			minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 		end
 		shouldUpdateFormspec=true
 		shouldRerunTimer=true
 	else
 		minetest.swap_node(pos,{
 			name="industrialtest:iron_furnace",
 			param2=minetest.get_node(pos).param2
 		})
 		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
 	if meta:get_float("srcTime")>=meta:get_float("maxSrcTime") then
 		local output,after=minetest.get_craft_result({
-				method="cooking",
+			method="cooking",
-				width=1,
+			width=1,
-				items={srcSlot}
+			items={srcSlot}
 		})
 		if output.item:get_count()>0 then
 			inv:set_stack("src",1,after.items[1])
@@ -194,133 +214,77 @@ ironFurnace.activeOnTimer=function(pos,elapsed)
 		end
 	end
-	if shouldUpdateFormspec then
+	return shouldUpdateFormspec
 		meta:set_string("formspec",ironFurnace.getFormspec(meta:get_float("fuelTime")/meta:get_float("maxFuelTime")*100,meta:get_float("srcTime")/meta:get_float("maxSrcTime")*100))
 	end
 	return shouldRerunTimer
 end
-ironFurnace.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
+function industrialtest.IronFurnace.shouldActivate(self,pos)
-	if toList=="dst" then
+	local meta=minetest.get_meta(pos)
-		return 0
+	local inv=meta:get_inventory()
-	end
+	local fuelSlot=inv:get_stack("fuel",1)
-	return count
+	if fuelSlot:get_count()>0 then
 end
 ironFurnace.allowMetadataInventoryPut=function(pos,listname,index,stack)
 	if listname=="dst" then
 		return 0
 	elseif listname=="src" then
 		local meta=minetest.get_meta(pos)
 		local inv=meta:get_inventory()
 		local srcSlot=inv:get_stack("src",1)
-		if srcSlot:get_name()~=stack:get_name() then
+		local output,after=minetest.get_craft_result({
-			meta:set_float("srcTime",-1)
+			method="cooking",
-			meta:set_float("maxSrcTime",0)
+			width=1,
 			items={srcSlot}
 		})
 		if output.time>0 and inv:room_for_item("dst",output.item) then
 			output,after=minetest.get_craft_result({
 				method="fuel",
 				width=1,
 				items={fuelSlot}
 			})
 			if output.time>0 then
 				meta:set_float("fuelTime",output.time)
 				meta:set_float("maxFuelTime",output.time)
 				inv:set_stack("fuel",1,after.items[1])
 				return true
 			end
 		end
 	end
-	return stack:get_count()
+	return false
 end
-ironFurnace.onMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
+function industrialtest.IronFurnace.shouldDeactivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	if meta:get_float("fuelTime")>0 then
 		return false
 	end
 	local inv=meta:get_inventory()
 	local srcSlot=inv:get_stack("src",1)
-	local dstSlot=inv:get_stack("dst",1)
+	local srcOutput,_=minetest.get_craft_result({
-	if fromList=="src" and count==srcSlot:get_count() then
+		method="cooking",
-		meta:set_float("srcTime",-1)
+		width=1,
-		meta:set_float("maxSrcTime",0)
+		items={srcSlot}
-		if meta:get_float("maxFuelTime")>0 then
+	})
-			meta:set_string("formspec",ironFurnaceFormspec(meta:get_float("fuelTime")/meta:get_float("maxFuelTime")*100,0))
+	if srcOutput.time==0 or not inv:room_for_item("dst",srcOutput.item) then
-		end
+		meta:set_float("srcTime",0)
-	elseif fromList=="dst" and dstSlot:get_free_space()==0 then
+		return true
 		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
 	local fuelSlot=inv:get_stack("fuel",1)
 	local fuelOutput,_=minetest.get_craft_result({
 		method="fuel",
 		width=1,
 		items={fuelSlot}
 	})
 	if fuelOutput.time==0 then
 		meta:set_float("srcTime",0)
 		return true
 	end
 	return false
 end
-ironFurnace.onMetadataInventoryPut=function(pos,listname,index,stack)
+function industrialtest.IronFurnace.afterDeactivation(self,pos)
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	self:updateFormspec(pos)
 end
-ironFurnace.onMetadataInventoryTake=function(pos,listname,index,stack)
+industrialtest.IronFurnace:register()
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcSlot=inv:get_stack("src",1)
 	local dstSlot=inv:get_stack("dst",1)
 	if listname=="src" and stack:get_count()==srcSlot:get_count() then
 		meta:set_float("srcTime",-1)
 		meta:set_float("maxSrcTime",0)
 		if meta:get_float("maxFuelTime")>0 then
 			meta:set_string("formspec",ironFurnaceFormspec(meta:get_float("fuelTime")/meta:get_float("maxFuelTime")*100,0))
 		end
 	elseif listname=="dst" and dstSlot:get_free_space()==0 then
 		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
 end
 local definition={
 	description=S("Iron Furnace"),
 	tiles={
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_iron_furnace_front.png",
 		"industrialtest_machine_block.png"
 	},
 	paramtype2="facedir",
 	legacy_facedir_simple=true,
 	on_construct=ironFurnace.onConstruct,
 	on_timer=ironFurnace.onTimer,
 	allow_metadata_inventory_move=ironFurnace.allowMetadataInventoryMove,
 	allow_metadata_inventory_put=ironFurnace.allowMetadataInventoryPut,
 	on_metadata_inventory_move=ironFurnace.onMetadataInventoryMove,
 	on_metadata_inventory_put=ironFurnace.onMetadataInventoryPut,
 	on_metadata_inventory_take=ironFurnace.onMetadataInventoryTake
 }
 if industrialtest.mtgAvailable then
 	definition.groups={
 		cracky=1,
 		level=2
 	}
 	definition.sounds=default.node_sound_metal_defaults()
 	definition.can_dig=function(pos)
 		local meta=minetest.get_meta(pos)
 		local inv=meta:get_inventory()
 		return not (inv:get_list("src")[1]:get_count()>0 or inv:get_list("fuel")[1]:get_count()>0 or inv:get_list("dst")[1]:get_count()>0)
 	end
 elseif industrialtest.mclAvailable then
 	definition.after_dig_node=function(pos,oldnode,oldmeta)
 		industrialtest.internal.mclAfterDigNode(pos,oldmeta,{"src","fuel","dst"})
 	end
 	definition.sounds=mcl_sounds.node_sound_metal_defaults()
 	definition._mcl_blast_resistance=3
 	definition._mcl_hardness=3.5
 end
 minetest.register_node("industrialtest:iron_furnace",definition)
 definition=table.copy(definition)
 definition.description=nil
 definition.tiles={
 	"industrialtest_machine_block.png",
 	"industrialtest_machine_block.png",
 	"industrialtest_machine_block.png",
 	"industrialtest_machine_block.png",
 	"industrialtest_machine_block.png",
 	"industrialtest_machine_block.png^industrialtest_iron_furnace_front_active.png",
 	"industrialtest_machine_block.png"
 }
 definition.light_source=8
 definition.drop="industrialtest:iron_furnace"
 definition.on_timer=ironFurnace.activeOnTimer
 if industrialtest.mclAvailable then
 	definition.groups={
 		not_in_creative_inventory=1
 	}
 	definition._doc_items_create_entry=false
 end
 minetest.register_node("industrialtest:iron_furnace_active",definition)
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:iron_furnace",
--- a/machines/macerator.lua
+++ b/machines/macerator.lua
@@ -15,18 +15,55 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-
+industrialtest.Macerator=table.copy(industrialtest.SimpleElectricItemProcessor)
-industrialtest.internal.registerSimpleElectricItemProcessor({
+industrialtest.internal.unpackTableInto(industrialtest.Macerator,{
-	name="macerator",
+	name="industrialtest:macerator",
-	displayName=S("Macerator"),
+	description=S("Macerator"),
-	customFrontTexture=true,
+	tiles={
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_macerator_front.png"
 	},
 	requiresWrench=true,
 	active={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_macerator_front_active.png"
 		}
 	},
 	capacity=1200,
 	flow=industrialtest.api.lvPowerFlow,
 	opPower=100,
 	method="industrialtest.macerating",
 	efficiency=1
 })
 function industrialtest.Macerator.getCraftResult(self,itemstack)
 	local output=industrialtest.api.getMaceratorRecipeResult(itemstack:get_name())
 	if not output then
 		return {
 			item=ItemStack(),
 			time=0,
 			src=itemstack
 		}
 	end
 	local srcAfter=ItemStack(itemstack:get_name())
 	srcAfter:set_count(itemstack:get_count()-1)
 	return {
 		item=ItemStack(output.output),
 		time=output.time,
 		src=srcAfter
 	}
 end
 industrialtest.Macerator:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:macerator",
--- a/machines/machine.lua
+++ b/machines/machine.lua
@@ -0,0 +1,305 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 industrialtest.Machine={}
 function industrialtest.Machine.onConstruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	if not self.withoutFormspec then
 		meta:set_string("formspec",self:getFormspec(pos))
 	end
 	self:trigger(pos)
 end
 function industrialtest.Machine.onDestruct(self)
 	-- dummy function
 end
 function industrialtest.Machine.afterPlaceNode(self,pos,placer,itemstack,pointed)
 	-- dummy function
 end
 function industrialtest.Machine.getFormspec(self,pos)
 	local formspec
 	if industrialtest.mtgAvailable then
 		formspec={
 			"formspec_version[4]",
 			"size[10.8,12]",
 			"label[0.5,0.5;"..self.description.."]",
 			"list[current_player;main;0.5,6.25;8,1]",
 			"list[current_player;main;0.5,7.5;8,3;8]",
 			"listring[current_player;main]"
 		}
 	elseif industrialtest.mclAvailable then
 		formspec={
 			"size[10.04,12]",
 			"label[0.25,0.25;"..self.description.."]",
 			"list[current_player;main;0.5,7;9,3;9]",
 			mcl_formspec.get_itemslot_bg(0.5,7,9,3),
 			"list[current_player;main;0.5,10.24;9,1]",
 			mcl_formspec.get_itemslot_bg(0.5,10.24,9,1),
 			"listring[current_player;main]"
 		}
 	end
 	return table.concat(formspec,"")
 end
 function industrialtest.Machine.updateFormspec(self,pos)
 	if self.withoutFormspec then
 		return
 	end
 	local meta=minetest.get_meta(pos)
 	meta:set_string("formspec",self:getFormspec(pos))
 end
 function industrialtest.Machine.canUpdate(self,pos)
 	return false
 end
 function industrialtest.Machine.trigger(self,pos)
 	local timer=minetest.get_node_timer(pos)
 	if not timer:is_started() then
 		minetest.debug("updating "..minetest.serialize(pos))
 		timer:start(industrialtest.updateDelay)
 	end
 end
 function industrialtest.Machine.triggerIfNeeded(self,pos)
 	if self:canUpdate(pos) then
 		self:trigger(pos)
 	end
 end
 function industrialtest.Machine.onTimer(self,pos,elapsed)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local shouldRerunTimer=false
 	local shouldUpdateFormspec=false
 	if self.update then
 		shouldRerunTimer,shouldUpdateFormspec=self:update(pos,elapsed,meta,inv)
 	end
 	if shouldUpdateFormspec then
 		self:updateFormspec(pos)
 	end
 	return shouldRerunTimer
 end
 function industrialtest.Machine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local movedItemStack=inv:get_stack(fromList,1)
 	if toList=="upgrades" then
 		return self.allowMoveToUpgradeSlot(pos,toIndex,movedItemStack)
 	end
 	return count
 end
 function industrialtest.Machine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
 	if listname=="upgrades" then
 		return self.allowMoveToUpgradeSlot(pos,index,stack)
 	end
 	return stack:get_count()
 end
 function industrialtest.Machine.allowMetadataInventoryTake(self,pos,listname,index,stack,player)
 	return stack:get_count()
 end
 function industrialtest.Machine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	if toList=="upgrades" then
 		local meta=minetest.get_meta(pos)
 		local inv=meta:get_inventory()
 		local stack=inv:get_stack(fromList,fromIndex)
 		industrialtest.internal.applyUpgrade(pos,meta,stack)
 	elseif fromList=="upgrades" then
 		local meta=minetest.get_meta(pos)
 		local inv=meta:get_inventory()
 		local stack=inv:get_stack(fromList,fromIndex)
 		industrialtest.internal.removeUpgrade(pos,meta,stack)
 	end
 end
 function industrialtest.Machine.onMetadataInventoryPut(self,pos,listname,index,stack)
 	if listname=="upgrades" then
 		local meta=minetest.get_meta(pos)
 		industrialtest.internal.applyUpgrade(pos,meta,stack)
 	end
 end
 function industrialtest.Machine.onMetadataInventoryTake(self,pos,listname,index,stack)
 	if listname=="upgrades" then
 		local meta=minetest.get_meta(pos)
 		industrialtest.internal.removeUpgrade(pos,meta,stack)
 	end
 end
 function industrialtest.Machine.onReceiveFields(self,pos,formname,fields)
 	-- dummy function
 end
 local function mclAfterDigNode(pos,oldmeta,lists)
 	-- Taken from https://git.minetest.land/MineClone2/MineClone2/src/branch/master/mods/ITEMS/mcl_furnaces/init.lua#L538
 	local meta=minetest.get_meta(pos)
 	local meta2=meta
 	meta:from_table(oldmeta)
 	local inv=meta:get_inventory()
 	for _,listname in ipairs(lists) do
 		local stack=inv:get_stack(listname,1)
 		if not stack:is_empty() then
 			local p = {x=pos.x+math.random(0, 10)/10-0.5, y=pos.y, z=pos.z+math.random(0, 10)/10-0.5}
 			minetest.add_item(p, stack)
 		end
 	end
 	meta:from_table(meta2:to_table())
 end
 function industrialtest.Machine.createDefinitionTable(self)
 	local def={
 		description=self.description,
 		tiles=self.tiles,
 		on_construct=function(pos)
 			self:onConstruct(pos)
 		end,
 		on_destruct=function(pos)
 			self:onDestruct(pos)
 		end,
 		after_place_node=function(pos,placer,itemstack,pointed)
 			self:afterPlaceNode(pos,placer,itemstack,pointed)
 		end,
 		on_timer=function(pos,elapsed)
 			return self:onTimer(pos,elapsed)
 		end,
 		allow_metadata_inventory_move=function(pos,fromList,fromIndex,toList,toIndex,count)
 			return self:allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count)
 		end,
 		allow_metadata_inventory_put=function(pos,listname,index,stack,player)
 			return self:allowMetadataInventoryPut(pos,listname,index,stack,player)
 		end,
 		allow_metadata_inventory_take=function(pos,listname,index,stack,player)
 			return self:allowMetadataInventoryTake(pos,listname,index,stack,player)
 		end,
 		on_metadata_inventory_put=function(pos,listname,index,stack,player)
 			self:onMetadataInventoryPut(pos,listname,index,stack)
 		end,
 		on_metadata_inventory_move=function(pos,fromList,fromIndex,toList,toIndex,count)
 			self:onMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex)
 		end,
 		on_metadata_inventory_take=function(pos,listname,index,stack,player)
 			self:onMetadataInventoryTake(pos,listname,index,stack)
 		end,
 		on_receive_fields=function(pos,formname,fields)
 			self:onReceiveFields(pos,formname,fields)
 		end,
 		_industrialtest_self=self
 	}
 	if industrialtest.mtgAvailable then
 		def.groups={cracky=2}
 		if self.sounds=="metal" then
 			def.sounds=default.node_sound_metal_defaults()
 		elseif self.sounds=="wood" then
 			def.sounds=default.node_sound_wood_defaults()
 		end
 		def.can_dig=function(pos)
 			local meta=minetest.get_meta(pos)
 			local inv=meta:get_inventory()
 			for _,value in ipairs(self.storageLists) do
 				if inv:get_stack(value,1):get_count()>0 then
 					return false
 				end
 			end
 			return true
 		end
 	elseif industrialtest.mclAvailable then
 		def.after_dig_node=function(pos,oldnode,oldmeta)
 			mclAfterDigNode(pos,oldmeta,self.storageLists)
 		end
 		if self.sounds=="metal" then
 			def.sounds=mcl_sounds.node_sound_metal_defaults()
 		elseif sounds=="wood" then
 			def.sounds=mcl_sounds.node_sound_wood_defaults()
 		end
 		def.groups={
 			pickaxey=1,
 			container=2
 		}
 		def._mcl_blast_resistance=3.5
 		def._mcl_hardness=3.9
 		def._mcl_hoppers_on_try_pull=function(pos, hop_pos, hop_inv, hop_list)
 			local meta = minetest.get_meta(pos)
 			local inv = meta:get_inventory()
 			local stack = inv:get_stack("dst", 1)
 			if not stack:is_empty() and hop_inv:room_for_item(hop_list, stack) then
 				return inv, "dst", 1
 			end
 			return nil, nil, nil
 		end
 		def._mcl_hoppers_on_try_push=function(pos, hop_pos, hop_inv, hop_list)
 			local meta = minetest.get_meta(pos)
 			local inv = meta:get_inventory()
 			return inv, "src", mcl_util.select_stack(hop_inv, hop_list, inv, "src")
 		end
 		def._mcl_hoppers_on_after_push=function(pos)
 			minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 		end
 	end
 	def.groups._industrialtest_wrenchUnmountable=1
 	if self.requiresWrench then
 		def.drop="industrialtest:machine_block"
 	end
 	if self.facedir then
 		def.paramtype2="facedir"
 		def.legacy_facedir_simple=true
 	end
 	if self.hasPowerInput then
 		def.groups._industrialtest_hasPowerInput=1
 	end
 	if self.hasPowerOutput then
 		def.groups._industrialtest_hasPowerOutput=1
 	end
 	return def
 end
 function industrialtest.Machine.register(self)
 	local def=self:createDefinitionTable()
 	minetest.register_node(self.name,def)
 	industrialtest.api.addTag(self.name,"usesTimer")
 end
 function industrialtest.Machine.allowMoveToUpgradeSlot(pos,toIndex,stack)
 	local def=minetest.registered_items[stack:get_name()]
 	if not def or not def.groups or not def.groups._industrialtest_machineUpgrade then
 		return 0
 	end
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local targetSlot=inv:get_stack("upgrades",toIndex)
 	if not targetSlot:is_empty() then
 		return 0
 	end
 	return stack:get_count()
 end
--- a/machines/mass_fabricator.lua
+++ b/machines/mass_fabricator.lua
@@ -15,20 +15,54 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-local massFabricator={}
+industrialtest.MassFabricator=table.copy(industrialtest.SimpleElectricItemProcessor)
-
+industrialtest.internal.unpackTableInto(industrialtest.MassFabricator,{
-industrialtest.internal.registerSimpleElectricItemProcessor({
+	name="industrialtest:mass_fabricator",
-	name="mass_fabricator",
+	description=S("Mass Fabricator"),
-	displayName=S("Mass Fabricator"),
+	tiles={
-	capacity=100000,
+		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png^industrialtest_mass_fabricator_front.png"
 	},
 	requiresWrench=true,
 	active={
 		tiles={
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png^industrialtest_mass_fabricator_front_active.png"
 		}
 	},
 	capacity=100000,
 	flow=industrialtest.api.evPowerFlow,
 	opPower=10000,
 	machineBlockTexture="industrialtest_advanced_machine_block.png",
 	customFrontTexture=true,
 	method="industrialtest.mass_fabricating",
 	efficiency=1
 })
 function industrialtest.MassFabricator.getCraftResult(self,itemstack)
 	if itemstack:get_count()<34 or itemstack:get_name()~="industrialtest:scrap" then
 		return {
 			item=ItemStack(),
 			time=0,
 			src=itemstack
 		}
 	end
 	local srcAfter=ItemStack(itemstack:get_name())
 	srcAfter:set_count(itemstack:get_count()-34)
 	return {
 		item=ItemStack("industrialtest:uu_matter"),
 		time=15,
 		src=srcAfter
 	}
 end
 industrialtest.MassFabricator:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:mass_fabricator",
--- a/machines/nuclear_reactor.lua
+++ b/machines/nuclear_reactor.lua
@@ -15,48 +15,234 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-local reactor={}
+industrialtest.Reactor=table.copy(industrialtest.ActivatedElectricMachine)
 industrialtest.internal.unpackTableInto(industrialtest.Reactor,{
 	name="industrialtest:nuclear_reactor",
 	description=S("Nuclear Reactor"),
 	tiles={
 		"industrialtest_machine_block.png^industrialtest_nuclear_reactor_top.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_nuclear_reactor_front.png"
 	},
 	sounds="metal",
 	requiresWrench=true,
 	facedir=true,
 	storageLists={
 		"charged",
 		"fuel"
 	},
 	powerLists={
 		{
 			list="charged",
 			direction="o"
 		}
 	},
 	active={
 		tiles={
 			"industrialtest_machine_block.png^industrialtest_nuclear_reactor_top.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_nuclear_reactor_front_active.png"
 		},
 		lightSource=2
 	},
 	capacity=industrialtest.api.evPowerFlow,
 	flow=industrialtest.api.evPowerFlow,
 	hasPowerOutput=true,
 	ioConfig="oooooo"
 })
-reactor.getFormspec=function(pos)
+function industrialtest.Reactor.onConstruct(self,pos)
 	local meta=minetest.get_meta(pos)
-	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
+	local inv=meta:get_inventory()
-	local switchText=(meta:get_int("enabled")==0 and S("Start") or S("Stop"))
+	inv:set_size("fuel",4)
 	local formspec
 	if industrialtest.mtgAvailable then
 		formspec={
 			"list[context;fuel;1,1;5,4]",
 			"listring[context;fuel]",
 			"list[context;charged;7.7,2.8;1,1]",
 			"listring[context;charged]",
 			"button[7.7,1;1,0.8;toggle;"..minetest.formspec_escape(switchText).."]",
 			"box[9,1;0.3,4.8;#202020]",
 			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or ""),
 		}
 	elseif industrialtest.mclAvailable then
 		formspec={
 			"list[context;fuel;1,1;5,4]",
 			mcl_formspec.get_itemslot_bg(1,1,5,4),
 			"listring[context;fuel]",
 			"list[context;charged;7,2.8;1,1]",
 			mcl_formspec.get_itemslot_bg(7.7,2.8,1,1),
 			"listring[context;charged]",
 			"button[7.7,1;1,0.8;toggle;"..minetest.formspec_escape(switchText).."]",
 			"box[9,1;0.3,4.8;#202020]",
 			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or "")
 		}
 	end
 	return table.concat(formspec,"")
 end
 reactor.onConstruct=function(pos,meta,inv)
 	inv:set_size("fuel",20)
 	inv:set_size("charged",1)
 	meta:set_int("heat",0)
 	meta:set_int("size",6)
 	meta:set_int("enabled",0)
 	meta:set_int("stateChanged",0)
 	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
 end
-local function hasFuel(fuelList)
+function industrialtest.Reactor.onDestruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	local chambers=minetest.deserialize(meta:get_string("chambers")) or {}
 	for _,chamber in ipairs(chambers) do
 		minetest.remove_node(chamber)
 		minetest.add_item(chamber,"industrialtest:nuclear_reactor_chamber")
 	end
 	industrialtest.ActivatedElectricMachine.onDestruct(self,pos)
 end
 function industrialtest.Reactor.getFormspec(self,pos)
 	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
 	local size=math.floor(meta:get_int("size")/3)
 	local switchText=(meta:get_int("enabled")==0 and S("Start") or S("Stop"))
 	local formspec={
 		"list[context;fuel;1,1;"..size..","..size.."]",
 		industrialtest.internal.getItemSlotBg(1,1,size,size),
 		"list[context;charged;7,2.8;1,1]",
 		industrialtest.internal.getItemSlotBg(7.7,2.8,1,1),
 		"button[7.7,1;1,0.8;toggle;"..minetest.formspec_escape(switchText).."]",
 		self.createPowerIndicatorWidget(charged,9,1),
 		"listring[context;fuel]"
 	}
 	return parentFormspec..table.concat(formspec,"")
 end
 function industrialtest.Reactor.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local movedItemStack=inv:get_stack(fromList,fromIndex)
 	local def=movedItemStack:get_definition()
 	if toList=="fuel" and (not def or not def.groups._industrialtest_placedInNuclearReactor) then
 		return 0
 	end
 	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 end
 function industrialtest.Reactor.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
 	local def=stack:get_definition()
 	if listname=="fuel" and (not def or not def.groups._industrialtest_placedInNuclearReactor) then
 		return 0
 	end
 	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
 end
 function industrialtest.Reactor.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	self.synchronizeChambers(pos)
 end
 function industrialtest.Reactor.onMetadataInventoryPut(self,pos,listname,index,stack,player)
 	industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
 	self.synchronizeChambers(pos)
 end
 function industrialtest.Reactor.onMetadataInventoryTake(self,pos,listname,index,stack)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryTake(self,pos,listname,index,stack)
 	self.synchronizeChambers(pos)
 end
 function industrialtest.Reactor.onReceiveFields(self,pos,formname,fields)
 	if not fields.toggle then
 		return
 	end
 	local meta=minetest.get_meta(pos)
 	if not self.hasFuel(pos) and meta:get_int("enabled")==0 then
 		return
 	end
 	if meta:get_int("enabled")==0 then
 		meta:set_int("enabled",1)
 	else
 		meta:set_int("enabled",0)
 		self:updateFormspec(pos)
 		self.synchronizeChambers(pos)
 	end
 	meta:set_int("stateChanged",1)
 	self:triggerIfNeeded(pos)
 end
 function industrialtest.Reactor.shouldActivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	if meta:get_int("stateChanged")==0 then
 		return false
 	end
 	return meta:get_int("enabled")>0 and self.hasFuel(pos)
 end
 function industrialtest.Reactor.shouldDeactivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	return meta:get_int("enabled")==0 or not self.hasFuel(pos)
 end
 function industrialtest.Reactor.afterActivation(self,pos)
 	local meta=minetest.get_meta(pos)
 	meta:set_int("stateChanged",0)
 	self.synchronizeChambers(pos)
 end
 function industrialtest.Reactor.afterDeactivation(self,pos)
 	local meta=minetest.get_meta(pos)
 	meta:set_int("enabled",0)
 	self:updateFormspec(pos)
 	self.synchronizeChambers(pos)
 end
 function industrialtest.Reactor.activeUpdate(self,pos,elapsed,meta,inv)
 	local size=math.floor(meta:get_int("size")/3)
 	local fuelList=inv:get_list("fuel")
 	local shouldRerunTimer=meta:get_int("enabled")>0
 	local shouldUpdateFormspec=false
 	local maxCluster=self.findMaxFuelCluster(size,fuelList)
 	for _,stack in ipairs(maxCluster) do
 		local index=stack.y*size+stack.x
 		local usedStack,_=self.useFuel(fuelList[index],5)
 		inv:set_stack("fuel",index,usedStack)
 	end
 	local generatedPowerAmount=math.pow(3,#maxCluster)
 	if industrialtest.api.addPower(meta,generatedPowerAmount)>0 then
 		shouldUpdateFormspec=true
 	end
 	local heat=meta:get_int("heat")+#maxCluster
 	local coolant=self.findCoolant(fuelList)
 	if coolant>0 then
 		local coolantStack,used=self.useFuel(fuelList[coolant],#maxCluster*50)
 		heat=math.max(0,heat-used)
 		inv:set_stack("fuel",coolant,coolantStack)
 	end
 	if heat>200 then
 		minetest.remove_node(pos)
 		industrialtest.internal.explode(pos,#maxCluster*4)
 		return false
 	end
 	meta:set_int("heat",heat)
 	self.synchronizeChambers(pos)
 	return shouldUpdateFormspec
 end
 function industrialtest.Reactor.changeSize(self,pos,diff)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local size=meta:get_int("size")+diff
 	local actualSize=math.floor(size/3)
 	meta:set_int("size",size)
 	inv:set_size("fuel",actualSize*actualSize)
 	self:updateFormspec(pos)
 end
 function industrialtest.Reactor.synchronizeToChamber(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local fuelList=inv:get_list("fuel")
 	local chargedList=inv:get_list("charged")
 	local reactorPos=minetest.deserialize(meta:get_string("reactor"))
 	local reactorMeta=minetest.get_meta(reactorPos)
 	local reactorInv=reactorMeta:get_inventory()
 	reactorInv:set_list("fuel",fuelList)
 	reactorInv:set_list("charged",chargedList)
 	self.synchronizeChambers(reactorPos)
 end
 function industrialtest.Reactor.hasFuel(pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local fuelList=inv:get_list("fuel")
 	for _,stack in ipairs(fuelList) do
 		if stack:get_name()=="industrialtest:uranium_cell" then
 			return true
@@ -65,12 +251,12 @@ local function hasFuel(fuelList)
 	return false
 end
-local function findMaxFuelCluster(fuelList)
+function industrialtest.Reactor.findMaxFuelCluster(size,fuelList)
 	local maxCluster={}
-	for y=1,4 do
+	for y=1,size do
-		for x=1,5 do
+		for x=1,size do
 			local iy=y-1
-			local stack=fuelList[iy*5+x]
+			local stack=fuelList[iy*size+x]
 			local def=minetest.registered_tools[stack:get_name()]
 			if def and def.groups._industrialtest_nuclearReactorFuel then
 				local cluster={
@@ -79,49 +265,49 @@ local function findMaxFuelCluster(fuelList)
 						y=iy
 					}
 				}
-				if x>1 and fuelList[iy*5+x-1]:get_name()==stack:get_name() then
+				if x>1 and fuelList[iy*size+x-1]:get_name()==stack:get_name() then
 					table.insert(cluster,{
 						x=x-1,
 						y=iy
 					})
 				end
-				if x<5 and fuelList[iy*5+x+1]:get_name()==stack:get_name() then
+				if x<size and fuelList[iy*size+x+1]:get_name()==stack:get_name() then
 					table.insert(cluster,{
 						x=x+1,
 						y=iy
 					})
 				end
-				if y>1 and fuelList[(iy-1)*5+x]:get_name()==stack:get_name() then
+				if y>1 and fuelList[(iy-1)*size+x]:get_name()==stack:get_name() then
 					table.insert(cluster,{
 						x=x,
 						y=iy-1
 					})
 				end
-				if y<4 and fuelList[(iy+1)*5+x]:get_name()==stack:get_name() then
+				if y<size and fuelList[(iy+1)*size+x]:get_name()==stack:get_name() then
 					table.insert(cluster,{
 						x=x,
 						y=iy+1
 					})
 				end
-				if x>1 and y>1 and fuelList[(iy-1)*5+x-1]:get_name()==stack:get_name() then
+				if x>1 and y>1 and fuelList[(iy-1)*size+x-1]:get_name()==stack:get_name() then
 					table.insert(cluster,{
 						x=x-1,
 						y=iy-1
 					})
 				end
-				if x<5 and y>1 and fuelList[(iy-1)*5+x+1]:get_name()==stack:get_name() then
+				if x<size and y>1 and fuelList[(iy-1)*size+x+1]:get_name()==stack:get_name() then
 					table.insert(cluster,{
 						x=x+1,
 						y=iy-1
 					})
 				end
-				if x>1 and y<4 and fuelList[(iy+1)*5+x-1]:get_name()==stack:get_name() then
+				if x>1 and y<size and fuelList[(iy+1)*size+x-1]:get_name()==stack:get_name() then
 					table.insert(cluster,{
 						x=x-1,
 						y=iy+1
 					})
 				end
-				if x<5 and y<4 and fuelList[(iy+1)*5+x+1]:get_name()==stack:get_name() then
+				if x<size and y<size and fuelList[(iy+1)*size+x+1]:get_name()==stack:get_name() then
 					table.insert(cluster,{
 						x=x+1,
 						y=iy+1
@@ -139,8 +325,8 @@ local function findMaxFuelCluster(fuelList)
 	return maxCluster
 end
-local function findCoolant(fuelList)
+function industrialtest.Reactor.findCoolant(fuelList)
-	for i=1,20 do
+	for i=1,#fuelList do
 		local stack=fuelList[i]
 		local def=minetest.registered_tools[stack:get_name()]
 		if def and def.groups._industrialtest_nuclearReactorCoolant then
@@ -150,7 +336,7 @@ local function findCoolant(fuelList)
 	return 0
 end
-local function useFuel(stack,use)
+function industrialtest.Reactor.useFuel(stack,use)
 	local used=math.min(65535-stack:get_wear(),use)
 	if used<use then
 		stack:replace("industrialtest:empty_cell")
@@ -160,216 +346,16 @@ local function useFuel(stack,use)
 	return stack,used
 end
-reactor.onTimer=function(pos,elapsed,meta,inv)
+function industrialtest.Reactor.synchronizeChambers(pos)
 	local powerFlow=meta:get_int("industrialtest.powerFlow")
 	local chargedSlot=inv:get_stack("charged",1)
 	local fuelList=inv:get_list("fuel")
 	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
 	local shouldRerunTimer=meta:get_int("enabled")>0
 	local shouldUpdateFormspec=false
 	if chargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(chargedSlot:get_meta()) and meta:get_int("industrialtest.powerAmount")>0 then
 		industrialtest.api.transferPowerToItem(meta,chargedSlot,powerFlow)
 		inv:set_stack("charged",1,chargedSlot)
 		shouldUpdateFormspec=true
 		shouldRerunTimer=true
 	end
 	if meta:get_int("stateChanged")>0 then
 		shouldUpdateFormspec=true
 		meta:set_int("stateChanged",0)
 	end
 	if meta:get_int("enabled")>0 and hasFuel(fuelList) then
 		minetest.swap_node(pos,{
 			name="industrialtest:nuclear_reactor_active",
 			param2=minetest.get_node(pos).param2
 		})
 		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 		shouldRerunTimer=false
 	end
 	return shouldRerunTimer,shouldUpdateFormspec
 end
 reactor.activeOnTimer=function(pos,elapsed,meta,inv)
 	local powerFlow=meta:get_int("industrialtest.powerFlow")
 	local chargedSlot=inv:get_stack("charged",1)
 	local fuelList=inv:get_list("fuel")
 	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
 	local shouldRerunTimer=meta:get_int("enabled")>0
 	local shouldUpdateFormspec=false
 	if chargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(chargedSlot:get_meta()) and meta:get_int("industrialtest.powerAmount")>0 then
 		industrialtest.api.transferPowerToItem(meta,chargedSlot,powerFlow)
 		inv:set_stack("charged",1,chargedSlot)
 		shouldUpdateFormspec=true
 		shouldRerunTimer=true
 	end
 	if meta:get_int("stateChanged")>0 then
 		shouldUpdateFormspec=true
 		meta:set_int("stateChanged",0)
 	end
 	if meta:get_int("enabled")==0 or not hasFuel(fuelList) then
 		minetest.swap_node(pos,{
 			name="industrialtest:nuclear_reactor",
 			param2=minetest.get_node(pos).param2
 		})
 		meta:set_int("enabled",0)
 		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 		return false,shouldUpdateFormspec
 	end
 	local maxCluster=findMaxFuelCluster(fuelList)
 	for _,stack in ipairs(maxCluster) do
 		local index=stack.y*5+stack.x
 		local usedStack,_=useFuel(fuelList[index],5)
 		inv:set_stack("fuel",index,usedStack)
 	end
 	local generatedPowerAmount=math.pow(3,#maxCluster)
 	if industrialtest.api.addPower(meta,generatedPowerAmount)>0 then
 		shouldUpdateFormspec=true
 	end
 	local heat=meta:get_int("heat")+#maxCluster
 	local coolant=findCoolant(fuelList)
 	if coolant>0 then
 		local coolantStack,used=useFuel(fuelList[coolant],#maxCluster*50)
 		heat=heat-used
 		inv:set_stack("fuel",coolant,coolantStack)
 	end
 	if heat>200 then
 		minetest.remove_node(pos)
 		industrialtest.internal.explode(pos,#maxCluster*4)
 		return false,false
 	end
 	meta:set_int("heat",heat)
 	return shouldRerunTimer,shouldUpdateFormspec
 end
 reactor.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
 	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
+	local chambers=meta:contains("chambers") and minetest.deserialize(meta:get_string("chambers")) or {}
-	local movedItemStack=inv:get_stack(fromList,fromIndex)
+	for _,chamber in ipairs(chambers) do
-	local def=minetest.registered_tools[movedItemStack:get_name()]
+		industrialtest.ReactorChamber:synchronize(chamber,pos)
 	if toList=="fuel" and (not def or not def.groups._industrialtest_placedInNuclearReactor) then
 		return 0
 	end
 	return count
 end
-reactor.allowMetadataInventoryPut=function(pos,listname,index,stack)
+industrialtest.Reactor:register()
 	local def=minetest.registered_tools[stack:get_name()]
 	if listname=="fuel" and (not def or not def.groups._industrialtest_placedInNuclearReactor) then
 		return 0
 	end
 	return stack:get_count()
 end
 reactor.metadataChange=function(pos)
 	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 end
 reactor.handleFormspecFields=function(pos,formname,fields)
 	if not fields.toggle then
 		return
 	end
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local fuelList=inv:get_list("fuel")
 	if not hasFuel(fuelList) and meta:get_int("enabled")==0 then
 		return
 	end
 	if meta:get_int("enabled")==0 then
 		meta:set_int("enabled",1)
 	else
 		meta:set_int("enabled",0)
 	end
 	meta:set_int("stateChanged",1)
 	reactor.metadataChange(pos)
 end
 local definition={
 	description=S("Nuclear Reactor Chamber"),
 	tiles={"industrialtest_machine_block.png^industrialtest_nuclear_reactor_top.png"},
 	drop="industrialtest:machine_block",
 	groups={
 		_industrialtest_wrenchUnmountable=1
 	}
 }
 if industrialtest.mtgAvailable then
 	definition.sounds=default.node_sound_metal_defaults()
 	definition.groups.cracky=1
 	definition.groups.level=2
 elseif industrialtest.mclAvailable then
 	definition.sounds=mcl_sounds.node_sound_metal_defaults()
 	definition._mcl_blast_resistance=6
 	definition._mcl_hardness=5
 end
 minetest.register_node("industrialtest:nuclear_reactor_chamber",definition)
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:nuclear_reactor_chamber",
 	recipe={
 		{"","industrialtest:copper_plate",""},
 		{"industrialtest:copper_plate","industrialtest:machine_block","industrialtest:copper_plate"},
 		{"","industrialtest:copper_plate",""}
 	}
 })
 industrialtest.internal.registerMachine({
 	name="nuclear_reactor",
 	displayName=S("Nuclear Reactor"),
 	getFormspec=reactor.getFormspec,
 	capacity=industrialtest.api.evPowerFlow,
 	flow=industrialtest.api.evPowerFlow,
 	ioConfig="oooooo",
 	requiresWrench=true,
 	registerActiveVariant=true,
 	powerSlots={"charged"},
 	storageSlots={"charged","fuel"},
 	sounds="metal",
 	groups={
 		_industrialtest_hasPowerOutput=1
 	},
 	customKeys={
 		tiles={
 			"industrialtest_machine_block.png^industrialtest_nuclear_reactor_top.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_nuclear_reactor_front.png",
 			"industrialtest_machine_block.png"
 		},
 		paramtype2="facedir",
 		legacy_facedir_simple=true,
 		on_receive_fields=reactor.handleFormspecFields
 	},
 	activeCustomKeys={
 		tiles={
 			"industrialtest_machine_block.png^industrialtest_nuclear_reactor_top.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_nuclear_reactor_front_active.png",
 			"industrialtest_machine_block.png"
 		},
 		light_source=2,
 		on_receive_fields=reactor.handleFormspecFields
 	},
 	onConstruct=reactor.onConstruct,
 	onTimer=reactor.onTimer,
 	activeOnTimer=reactor.activeOnTimer,
 	allowMetadataInventoryMove=reactor.allowMetadataInventoryMove,
 	allowMetadataInventoryPut=reactor.allowMetadataInventoryPut,
 	onMetadataInventoryMove=reactor.metadataChange,
 	onMetadataInventoryPut=reactor.metadataChange
 })
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:nuclear_reactor",
@@ -379,3 +365,153 @@ minetest.register_craft({
 		{"","industrialtest:generator",""}
 	}
 })
 industrialtest.ReactorChamber=table.copy(industrialtest.Machine)
 industrialtest.internal.unpackTableInto(industrialtest.ReactorChamber,{
 	name="industrialtest:nuclear_reactor_chamber",
 	description=S("Nuclear Reactor Chamber"),
 	tiles={"industrialtest_machine_block.png^industrialtest_nuclear_reactor_top.png"},
 	sounds="metal",
 	storageLists={
 		"charged",
 		"fuel"
 	},
 	requiresWrench=true
 })
 function industrialtest.ReactorChamber.onDestruct(self,pos)
 	industrialtest.Machine.onDestruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	if not meta:contains("reactor") then
 		return
 	end
 	local reactorPos=minetest.deserialize(meta:get_string("reactor"))
 	local reactorMeta=minetest.get_meta(reactorPos)
 	if not reactorMeta or not reactorMeta:contains("chambers") then
 		return
 	end
 	local chambers=minetest.deserialize(reactorMeta:get_string("chambers"))
 	for i,chamber in ipairs(chambers) do
 		if chamber.x==pos.x and chamber.y==pos.y and chamber.z==pos.z then
 			table.remove(chambers,i)
 			break
 		end
 	end
 	reactorMeta:set_string("chambers",minetest.serialize(chambers))
 	industrialtest.Reactor:changeSize(reactorPos,-1)
 	industrialtest.Reactor.synchronizeChambers(reactorPos)
 end
 function industrialtest.ReactorChamber.afterPlaceNode(self,pos)
 	local neighbours={
 		vector.offset(pos,-1,0,0),
 		vector.offset(pos,1,0,0),
 		vector.offset(pos,0,-1,0),
 		vector.offset(pos,0,1,0),
 		vector.offset(pos,0,0,-1),
 		vector.offset(pos,0,0,1)
 	}
 	local reactorPos=nil
 	for _,neighbour in ipairs(neighbours) do
 		local node=minetest.get_node(neighbour)
 		if node.name=="industrialtest:nuclear_reactor" or node.name=="industrialtest:nuclear_reactor_active" then
 			reactorPos=neighbour
 		end
 	end
 	if not reactorPos then
 		minetest.remove_node(pos)
 		return true
 	end
 	local meta=minetest.get_meta(pos)
 	meta:set_string("reactor",minetest.serialize(reactorPos))
 	industrialtest.Reactor:changeSize(reactorPos,1)
 	industrialtest.Reactor.synchronizeChambers(reactorPos)
 	local reactorMeta=minetest.get_meta(reactorPos)
 	local chambers=reactorMeta:contains("chambers") and minetest.deserialize(reactorMeta:get_string("chambers")) or {}
 	table.insert(chambers,pos)
 	reactorMeta:set_string("chambers",minetest.serialize(chambers))
 	industrialtest.api.createNetworkMapForNode(reactorPos)
 	self:synchronize(pos,reactorPos)
 end
 function industrialtest.ReactorChamber.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	if not meta:contains("reactor") then
 		return ""
 	end
 	local reactorPos=minetest.deserialize(meta:get_string("reactor"))
 	return industrialtest.Reactor:getFormspec(reactorPos)
 end
 function industrialtest.ReactorChamber.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	return industrialtest.Reactor:allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count)
 end
 function industrialtest.ReactorChamber.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
 	return industrialtest.Reactor:allowMetadataInventoryPut(pos,listname,index,stack,player)
 end
 function industrialtest.ReactorChamber.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	industrialtest.Machine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	industrialtest.Reactor:synchronizeToChamber(pos)
 end
 function industrialtest.ReactorChamber.onMetadataInventoryPut(self,pos,listname,index,stack,player)
 	industrialtest.Machine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
 	industrialtest.Reactor:synchronizeToChamber(pos)
 end
 function industrialtest.ReactorChamber.onMetadataInventoryTake(self,pos,listname,index,stack)
 	industrialtest.Machine.onMetadataInventoryTake(self,pos,listname,index,stack)
 	industrialtest.Reactor:synchronizeToChamber(pos)
 end
 function industrialtest.ReactorChamber.onReceiveFields(self,pos,formname,fields)
 	local meta=minetest.get_meta(pos)
 	local reactorPos=minetest.deserialize(meta:get_string("reactor"))
 	industrialtest.Reactor:onReceiveFields(reactorPos,formname,fields)
 end
 function industrialtest.ReactorChamber.createDefinitionTable(self)
 	local def=industrialtest.Machine.createDefinitionTable(self)
 	def.groups._industrialtest_cable=1
 	def._industrialtest_cableFlow=industrialtest.api.evPowerFlow
 	return def
 end
 function industrialtest.ReactorChamber.synchronize(self,pos,reactor)
 	self:updateFormspec(pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local reactorMeta=minetest.get_meta(reactor)
 	local reactorInv=reactorMeta:get_inventory()
 	local fuelList=reactorInv:get_list("fuel")
 	local chargedList=reactorInv:get_list("charged")
 	inv:set_size("fuel",#fuelList)
 	inv:set_size("charged",#chargedList)
 	inv:set_list("fuel",fuelList)
 	inv:set_list("charged",chargedList)
 end
 industrialtest.ReactorChamber:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:nuclear_reactor_chamber",
 	recipe={
 		{"","industrialtest:lead_plate",""},
 		{"industrialtest:lead_plate","industrialtest:machine_block","industrialtest:lead_plate"},
 		{"","industrialtest:lead_plate",""}
 	}
 })
--- a/machines/power_storage.lua
+++ b/machines/power_storage.lua
@@ -15,121 +15,73 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-local powerStorage={}
+industrialtest.PowerStorage=table.copy(industrialtest.ElectricMachine)
 industrialtest.internal.unpackTableInto(industrialtest.PowerStorage,{
 	facedir=true,
 	storageLists={
 		"charged",
 		"discharged"
 	},
 	powerLists={
 		{
 			list="charged",
 			direction="o"
 		},
 		{
 			list="discharged",
 			direction="i"
 		}
 	},
 	hasPowerInput=true,
 	hasPowerOutput=true,
 	ioConfig="iiiioi"
 })
-powerStorage.getFormspec=function(pos)
+function industrialtest.PowerStorage.onConstruct(self,pos)
 	local meta=minetest.get_meta(pos)
-	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
+	local inv=meta:get_inventory()
 	local formspec
 	if industrialtest.mtgAvailable then
 		formspec={
 			"list[context;charged;1,2.5;1,1]",
 			"listring[context;charged]",
 			"label[0.9,3.9;"..S("Charge").."]",
 			"list[context;discharged;3,2.5;1,1]",
 			"listring[context;discharged]",
 			"label[2.7,3.9;"..S("Discharge").."]",
 			"box[9,1;0.3,4.8;#202020]",
 			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or "")
 		}
 	elseif industrialtest.mclAvailable then
 		formspec={
 			"list[context;charged;1,2.5;1,1]",
 			"listring[context;charged]",
 			mcl_formspec.get_itemslot_bg(1,2.5,1,1),
 			"label[0.9,3.9;"..S("Charge").."]",
 			"list[context;discharged;3,2.5;1,1]",
 			"listring[context;discharged]",
 			mcl_formspec.get_itemslot_bg(3,2.5,1,1),
 			"label[2.7,3.9;"..S("Discharge").."]",
 			"box[9,1;0.3,4.8;#202020]",
 			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or "")
 		}
 	end
 	return table.concat(formspec,"")
 end
 powerStorage.onConstruct=function(pos,meta,inv)
 	inv:set_size("charged",1)
 	inv:set_size("discharged",1)
 	industrialtest.ElectricMachine.onConstruct(self,pos)
 end
-powerStorage.onTimer=function(pos,elapsed,meta,inv,config)
+function industrialtest.PowerStorage.getFormspec(self,pos)
-	local chargedSlot=inv:get_stack("charged",1)
+	local parentFormspec=industrialtest.ElectricMachine.getFormspec(self,pos)
-	local dischargedSlot=inv:get_stack("discharged",1)
+	local meta=minetest.get_meta(pos)
-	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
+	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
-	local shouldUpdateFormspec=flowTransferred
+	local formspec={
-	local shouldRerunTimer=(afterFlow and meta:get_int("industrialtest.powerAmount")>0)
+		"list[context;charged;1,2.5;1,1]",
-
+		industrialtest.internal.getItemSlotBg(1,2.5,1,1),
-	if chargedSlot:get_count()>0 and meta:get_int("industrialtest.powerAmount")>0 and industrialtest.api.transferPowerToItem(meta,chargedSlot,config.flow)>0 then
+		"label[0.9,3.9;"..S("Charge").."]",
-		inv:set_stack("charged",1,chargedSlot)
+		"list[context;discharged;3,2.5;1,1]",
-		shouldRerunTimer=true
+		industrialtest.internal.getItemSlotBg(3,2.5,1,1),
-		shouldUpdateFormspec=true
+		"label[2.7,3.9;"..S("Discharge").."]",
-	end
+		self.createPowerIndicatorWidget(charged,9,1),
-	if dischargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(meta) and industrialtest.api.transferPowerFromItem(dischargedSlot,meta,config.flow)>0 then
+		"listring[context;charged]",
-		inv:set_stack("discharged",1,dischargedSlot)
+		"listring[context;discharged]"
-		shouldRerunTimer=true
+	}
-		shouldUpdateFormspec=true
+	return parentFormspec..table.concat(formspec,"")
 	end
 	return shouldRerunTimer,shouldUpdateFormspec
 end
-powerStorage.onMetadataInventoryPut=function(pos)
+industrialtest.BatBox=table.copy(industrialtest.PowerStorage)
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+industrialtest.internal.unpackTableInto(industrialtest.BatBox,{
-end
+	name="industrialtest:batbox",
-
+	description=S("BatBox"),
-powerStorage.onMetadataInventoryMove=function(pos)
+	tiles={
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		"industrialtest_wood_machine_block.png",
-end
+		"industrialtest_wood_machine_block.png",
-
+		"industrialtest_wood_machine_block.png",
-local function registerPowerStorageNode(config)
+		"industrialtest_wood_machine_block.png",
-	industrialtest.internal.registerMachine({
+		"industrialtest_wood_machine_block.png",
-		name=config.name,
+		"industrialtest_wood_machine_block.png^industrialtest_batbox_front.png"
-		displayName=config.displayName,
+	},
 		capacity=config.capacity,
 		flow=config.flow,
 		ioConfig="iiiioi",
 		sounds=config.sounds,
 		powerSlots={"charged","discharged"},
 		storageSlots={"charged","discharged"},
 		registerActiveVariant=false,
 		groups={
 			_industrialtest_hasPowerOutput=1,
 			_industrialtest_hasPowerInput=1
 		},
 		customKeys={
 			tiles={
 				config.machineBlockTexture,
 				config.machineBlockTexture,
 				config.machineBlockTexture,
 				config.machineBlockTexture,
 				config.machineBlockTexture,
 				config.machineBlockTexture.."^industrialtest_"..config.name.."_front.png"
 			},
 			paramtype2="facedir",
 			legacy_facedir_simple=true
 		},
 		requiresWrench=config.requiresWrench,
 		getFormspec=powerStorage.getFormspec,
 		onConstruct=powerStorage.onConstruct,
 		onTimer=function(pos,elapsed,meta,inv)
 			return powerStorage.onTimer(pos,elapsed,meta,inv,config)
 		end,
 		onMetadataInventoryPut=powerStorage.onMetadataInventoryPut,
 		onMetadataInventoryMove=powerStorage.onMetadataInventoryMove
 	})
 end
 registerPowerStorageNode({
 	name="batbox",
 	displayName=S("BatBox"),
 	capacity=25000,
 	flow=industrialtest.api.lvPowerFlow,
 	sounds="wood",
-	machineBlockTexture="industrialtest_wood_machine_block.png",
+	capacity=25000,
-	requiresWrench=false
+	flow=industrialtest.api.lvPowerFlow
 })
 industrialtest.BatBox:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:batbox",
@@ -140,15 +92,25 @@ minetest.register_craft({
 	}
 })
-registerPowerStorageNode({
+industrialtest.CESU=table.copy(industrialtest.PowerStorage)
-	name="cesu",
+industrialtest.internal.unpackTableInto(industrialtest.CESU,{
-	displayName=S("CESU"),
+	name="industrialtest:cesu",
-	capacity=400000,
+	description=S("CESU"),
-	flow=industrialtest.api.mvPowerFlow,
+	tiles={
 		"industrialtest_bronze_machine_block.png",
 		"industrialtest_bronze_machine_block.png",
 		"industrialtest_bronze_machine_block.png",
 		"industrialtest_bronze_machine_block.png",
 		"industrialtest_bronze_machine_block.png",
 		"industrialtest_bronze_machine_block.png^industrialtest_cesu_front.png"
 	},
 	sounds="metal",
-	machineBlockTexture="industrialtest_bronze_machine_block.png",
+	capacity=400000,
-	requiresWrench=false
+	flow=industrialtest.api.mvPowerFlow
 })
 industrialtest.CESU:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:cesu",
@@ -159,15 +121,26 @@ minetest.register_craft({
 	}
 })
-registerPowerStorageNode({
+industrialtest.MFE=table.copy(industrialtest.PowerStorage)
-	name="mfe",
+industrialtest.internal.unpackTableInto(industrialtest.MFE,{
-	displayName=S("MFE"),
+	name="industrialtest:mfe",
-	capacity=3000000,
+	description=S("MFE"),
-	flow=industrialtest.api.hvPowerFlow,
+	tiles={
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_mfe_front.png"
 	},
 	sounds="metal",
-	machineBlockTexture="industrialtest_machine_block.png",
+	requiresWrench=true,
-	requiresWrench=true
+	capacity=3000000,
 	flow=industrialtest.api.hvPowerFlow
 })
 industrialtest.MFE:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:mfe",
@@ -178,15 +151,27 @@ minetest.register_craft({
 	}
 })
-registerPowerStorageNode({
+
-	name="mfsu",
+industrialtest.MFSU=table.copy(industrialtest.PowerStorage)
-	displayName=S("MFSU"),
+industrialtest.internal.unpackTableInto(industrialtest.MFSU,{
-	capacity=30000000,
+	name="industrialtest:mfsu",
-	flow=industrialtest.api.evPowerFlow,
+	description=S("MFSU"),
 	tiles={
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png^industrialtest_mfsu_front.png"
 	},
 	sounds="metal",
-	machineBlockTexture="industrialtest_advanced_machine_block.png",
+	requiresWrench=true,
-	requiresWrench=false
+	capacity=30000000,
 	flow=industrialtest.api.evPowerFlow
 })
 industrialtest.MFSU:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:mfsu",
--- a/machines/recycler.lua
+++ b/machines/recycler.lua
@@ -15,18 +15,47 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-
+industrialtest.Recycler=table.copy(industrialtest.SimpleElectricItemProcessor)
-industrialtest.internal.registerSimpleElectricItemProcessor({
+industrialtest.internal.unpackTableInto(industrialtest.Recycler,{
-	name="recycler",
+	name="industrialtest:recycler",
-	displayName=S("Recycler"),
+	description=S("Recycler"),
-	customTopTexture=true,
+	tiles={
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_recycler_front.png"
 	},
 	requiresWrench=true,
 	active={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_recycler_front_active.png"
 		}
 	},
 	capacity=80,
 	flow=industrialtest.api.lvPowerFlow,
 	opPower=40,
 	method="industrialtest.recycling",
 	efficiency=1
 })
 function industrialtest.Recycler.getCraftResult(self,itemstack)
 	local srcAfter=ItemStack(itemstack:get_name())
 	srcAfter:set_count(itemstack:get_count()-1)
 	return {
 		item=ItemStack(industrialtest.random:next(1,8)==1 and "industrialtest:scrap" or ""),
 		time=2,
 		src=srcAfter
 	}
 end
 industrialtest.Recycler:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:recycler",
--- a/machines/rotary_macerator.lua
+++ b/machines/rotary_macerator.lua
@@ -0,0 +1,302 @@
 -- IndustrialTest
 -- Copyright (C) 2024 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
 industrialtest.RotaryMacerator=table.copy(industrialtest.ActivatedElectricMachine)
 industrialtest.internal.unpackTableInto(industrialtest.RotaryMacerator,{
 	name="industrialtest:rotary_macerator",
 	description=S("Rotary Macerator"),
 	tiles={
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png",
 		"industrialtest_advanced_machine_block.png^industrialtest_macerator_front.png"
 	},
 	sounds="metal",
 	requiresWrench=true,
 	facedir=true,
 	storageLists={
 		"src",
 		"dst",
 		"upgrades",
 		"powerStorage"
 	},
 	powerLists={
 		{
 			list="powerStorage",
 			direction="i"
 		}
 	},
 	active={
 		tiles={
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png^industrialtest_macerator_front_active.png"
 		}
 	},
 	capacity=industrialtest.api.lvPowerFlow*2,
 	flow=industrialtest.api.lvPowerFlow,
 	hasPowerInput=true,
 	ioConfig="iiiiii",
 	_opPower=60,
 	_maintainSpeedOpPower=10
 })
 function industrialtest.RotaryMacerator.onConstruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	inv:set_size("src",1)
 	inv:set_size("modifier",1)
 	inv:set_size("powerStorage",1)
 	inv:set_size("dst",1)
 	inv:set_size("upgrades",4)
 	meta:set_int("rpm",0)
 	meta:set_float("srcTime",0)
 	meta:set_float("maxSrcTime",0)
 	meta:set_int("maintainSpeed",0)
 	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
 end
 function industrialtest.RotaryMacerator.getFormspec(self,pos)
 	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
 	local maxSrcTime=meta:get_float("maxSrcTime")
 	local srcPercent=maxSrcTime>0 and meta:get_float("srcTime")/maxSrcTime*100 or 0
 	local rpm=meta:get_int("rpm")
 	local buttonMaintainSpeedText=meta:get_int("maintainSpeed")==1 and S("Don't maintain speed") or S("Maintain speed")
 	local formspec={
 		"list[context;src;3.8,1.8;1,1]",
 		industrialtest.internal.getItemSlotBg(3.8,1.8,1,1),
 		"list[context;modifier;4.9,1.8;1,1]",
 		industrialtest.internal.getItemSlotBg(4.9,1.8,1,1),
 		(powerPercent>0 and "image[3.8,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
 		 or "image[3.8,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
 		"list[context;powerStorage;3.8,3.9;1,1]",
 		industrialtest.internal.getItemSlotBg(3.8,3.9,1,1),
 		(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
 		 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
 		"list[context;dst;6,2.8;1,1;]",
 		industrialtest.internal.getItemSlotBg(6,2.8,1,1),
 		"list[context;upgrades;9,0.9;1,4]",
 		industrialtest.internal.getItemSlotBg(9,0.9,1,4),
 		"label[0.5,2.8;"..minetest.formspec_escape(S("Speed: @1",rpm)).."]",
 		"button[0.5,3.4;3,0.8;maintainSpeed;"..minetest.formspec_escape(buttonMaintainSpeedText).."]",
 		"listring[context;src]",
 		"listring[context;dst]"
 	}
 	return parentFormspec..table.concat(formspec,"")
 end
 function industrialtest.RotaryMacerator.update(self,pos,elapsed,meta,inv)
 	local shouldRerunTimer=false
 	local shouldUpdateFormspec=false
 	local rpm=meta:get_int("rpm")
 	local maintainSpeed=meta:get_int("maintainSpeed")
 	local powerAmount=meta:get_int("industrialtest.powerAmount")
 	if maintainSpeed==1 and powerAmount>=self._maintainSpeedOpPower then
 		local newRpm=math.max(rpm+10*elapsed,0)
 		if newRpm>rpm then
 			meta:set_int("rpm",newRpm)
 			shouldUpdateFormspec=true
 		end
 		industrialtest.api.addPower(meta,-self._maintainSpeedOpPower)
 		shouldRerunTimer=true
 	elseif rpm>0 then
 		meta:set_int("rpm",math.max(rpm-1000*elapsed,0))
 		shouldRerunTimer=rpm>0
 		shouldUpdateFormspec=true
 	end
 	return shouldRerunTimer,shouldUpdateFormspec
 end
 function industrialtest.RotaryMacerator.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,count)
 	if toList=="dst" then
 		return 0
 	end
 	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 end
 function industrialtest.RotaryMacerator.allowMetadataInventoryPut(self,pos,listname,index,stack)
 	if listname=="dst" then
 		return 0
 	end
 	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack)
 end
 function industrialtest.RotaryMacerator.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	if toList=="src" or toList=="modifier" or fromList=="dst" then
 		self:triggerIfNeeded(pos)
 	end
 end
 function industrialtest.RotaryMacerator.onMetadataInventoryPut(self,pos,listname,index,stack,player)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack,player)
 	if listname=="src" or listname=="modifier" then
 		self:triggerIfNeeded(pos)
 	end
 end
 function industrialtest.RotaryMacerator.onMetadataInventoryTake(self,pos,listname,index,stack)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryTake(self,pos,listname,index,stack)
 	if listname=="dst" then
 		self:triggerIfNeeded(pos)
 	end
 end
 function industrialtest.RotaryMacerator.onReceiveFields(self,pos,formname,fields)
 	if not fields.maintainSpeed then
 		return
 	end
 	local meta=minetest.get_meta(pos)
 	local maintainSpeed=meta:get_int("maintainSpeed")
 	if maintainSpeed==1 then
 		meta:set_int("maintainSpeed",0)
 	elseif meta:get_int("industrialtest.powerAmount")>=self._maintainSpeedOpPower then
 		meta:set_int("maintainSpeed",1)
 		self:trigger(pos)
 	end
 	self:updateFormspec(pos)
 end
 function industrialtest.RotaryMacerator.shouldActivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	local powerAmount=meta:get_int("industrialtest.powerAmount")
 	if powerAmount<self._opPower then
 		return false
 	end
 	local inv=meta:get_inventory()
 	local result,_=self.getRecipeResult(pos)
 	if not result or result.time==0 or not inv:room_for_item("dst",ItemStack(result.output)) then
 		return false
 	end
 	return true
 end
 function industrialtest.RotaryMacerator.shouldDeactivate(self,pos)
 	return not self:shouldActivate(pos)
 end
 function industrialtest.RotaryMacerator.afterDeactivation(self,pos)
 	local meta=minetest.get_meta(pos)
 	meta:set_float("srcTime",0)
 	meta:set_float("maxSrcTime",0)
 end
 function industrialtest.RotaryMacerator.activeUpdate(self,pos,elapsed,meta,inv)
 	local srcSlot=inv:get_stack("src",1)
 	local dstSlot=inv:get_stack("dst",1)
 	local powerAmount=meta:get_int("industrialtest.powerAmount")
 	local rpm=meta:get_int("rpm")
 	local maxSrcTime=meta:get_float("maxSrcTime")
 	local speed=industrialtest.api.getMachineSpeed(meta)
 	local requiredPower=elapsed*self._opPower*speed
 	if maxSrcTime<=0 then
 		local result,_=self.getRecipeResult(pos)
 		meta:set_float("maxSrcTime",result.time)
 		maxSrcTime=result.time
 	end
 	local srcTime=meta:get_float("srcTime")+elapsed*(1+rpm/7500)
 	if srcTime>=maxSrcTime then
 		local result,modified=self.getRecipeResult(pos)
 		local resultStack=ItemStack(result.output)
 		local multiplier=math.min(srcSlot:get_count(),speed)
 		local prevCount=resultStack:get_count()
 		resultStack:set_count(resultStack:get_count()*multiplier)
 		local leftover=inv:add_item("dst",resultStack)
 		meta:set_float("srcTime",0)
 		srcSlot:take_item(multiplier-leftover:get_count()/prevCount)
 		inv:set_stack("src",1,srcSlot)
 		meta:set_int("rpm",math.min(rpm+750*elapsed,7500))
 		if modified then
 			local modifierSlot=inv:get_stack("modifier",1)
 			local modifierMeta=modifierSlot:get_meta()
 			local uses=result.uses
 			local replace=false
 			if modifierMeta:contains("uses") then
 				uses=modifierMeta:get_int("uses")
 			else
 				replace=true
 			end
 			uses=math.max(uses-1,0)
 			if uses==0 then
 				if result.modifierLeftover then
 					modifierSlot:set_name(result.modifierLeftover)
 				else
 					modifierSlot:take_item(1)
 				end
 				uses=result.uses
 			end
 			if not modifierSlot:is_empty() and not result.modifierLeftover then
 				local modifierDef=modifierSlot:get_definition()
 				modifierMeta:set_int("uses",uses)
 				modifierMeta:set_string("description",string.format("%s (%s: %d)",modifierDef.description,S("Uses"),uses))
 			end
 			if replace then
 				modifierSlot:set_name(result.stackLeftover)
 			end
 			inv:set_stack("modifier",1,modifierSlot)
 		end
 	else
 		meta:set_float("srcTime",srcTime)
 	end
 	industrialtest.api.addPower(meta,-requiredPower)
 	return true
 end
 industrialtest.RotaryMacerator:register()
 function industrialtest.RotaryMacerator.getRecipeResult(pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcSlot=inv:get_stack("src",1)
 	local modifierSlot=inv:get_stack("modifier",1)
 	local result
 	local modified=false
 	if modifierSlot:is_empty() then
 		result=industrialtest.api.getMaceratorRecipeResult(srcSlot:get_name())
 	else
 		result=industrialtest.api.getRotaryMaceratorModifier(srcSlot:get_name(),modifierSlot:get_name())
 		modified=true
 	end
 	return result,modified
 end
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:rotary_macerator",
 	recipe={
 		{"industrialtest:refined_iron_ingot","industrialtest:refined_iron_ingot","industrialtest:refined_iron_ingot"},
 		{"industrialtest:refined_iron_ingot","industrialtest:macerator","industrialtest:refined_iron_ingot"},
 		{"industrialtest:refined_iron_ingot","industrialtest:advanced_machine_block","industrialtest:refined_iron_ingot"}
 	}
 })
--- a/machines/simple_electric_item_processor.lua
+++ b/machines/simple_electric_item_processor.lua
@@ -0,0 +1,220 @@
 -- IndustrialTest
 -- Copyright (C) 2025 mrkubax10
 -- This program is free software: you can redistribute it and/or modify
 -- it under the terms of the GNU General Public License as published by
 -- the Free Software Foundation, either version 3 of the License, or
 -- (at your option) any later version.
 -- This program is distributed in the hope that it will be useful,
 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 -- GNU General Public License for more details.
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 industrialtest.SimpleElectricItemProcessor=table.copy(industrialtest.ActivatedElectricMachine)
 industrialtest.internal.unpackTableInto(industrialtest.SimpleElectricItemProcessor,{
 	facedir=true,
 	sounds="metal",
 	storageLists={
 		"src",
 		"dst",
 		"powerStorage",
 		"upgrades"
 	},
 	powerLists={
 		{
 			list="powerStorage",
 			direction="i"
 		}
 	},
 	hasPowerInput=true,
 	ioConfig="iiiiii"
 })
 function industrialtest.SimpleElectricItemProcessor.onConstruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	inv:set_size("src",1)
 	inv:set_size("dst",1)
 	inv:set_size("powerStorage",1)
 	inv:set_size("upgrades",4)
 	meta:set_float("srcTime",-1)
 	meta:set_float("maxSrcTime",0)
 	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
 end
 function industrialtest.SimpleElectricItemProcessor.getFormspec(self,pos)
 	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
 	local srcPercent=meta:get_float("srcTime")/meta:get_float("maxSrcTime")*100
 	local formspec={
 		"list[context;src;3.4,1.8;1,1]",
 		industrialtest.internal.getItemSlotBg(3.4,1.8,1,1),
 		(powerPercent>0 and "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
 		 or "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
 		"list[context;powerStorage;3.4,3.9;1,1]",
 		industrialtest.internal.getItemSlotBg(3.4,3.9,1,1),
 		(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
 		 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
 		"list[context;dst;6.4,2.8;1,1]",
 		industrialtest.internal.getItemSlotBg(6.4,2.8,1,1),
 		"list[context;upgrades;9,0.9;1,4]",
 		industrialtest.internal.getItemSlotBg(9,0.9,1,4),
 		"listring[context;src]",
 		"listring[context;dst]"
 	}
 	return parentFormspec..table.concat(formspec,"")
 end
 function industrialtest.SimpleElectricItemProcessor.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,count)
 	if toList=="dst" then
 		return 0
 	end
 	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,count)
 end
 function industrialtest.SimpleElectricItemProcessor.allowMetadataInventoryPut(self,pos,listname,index,stack)
 	if listname=="dst" then
 		return 0
 	elseif listname=="src" then
 		local meta=minetest.get_meta(pos)
 		local inv=meta:get_inventory()
 		local srcSlot=inv:get_stack("src",1)
 		if srcSlot:get_name()~=stack:get_name() then
 			meta:set_float("srcTime",-1)
 			meta:set_float("maxSrcTime",0)
 		end
 	end
 	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack)
 end
 function industrialtest.SimpleElectricItemProcessor.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcSlot=inv:get_stack("src",1)
 	local dstSlot=inv:get_stack("dst",1)
 	if fromList=="src" and srcSlot:is_empty() then
 		meta:set_float("srcTime",-1)
 		meta:set_float("maxSrcTime",0)
 		self:updateFormspec(pos)
 	elseif fromList=="dst" and dstSlot:get_free_space()>0 then
 		self:triggerIfNeeded(pos)
 	end
 end
 function industrialtest.SimpleElectricItemProcessor.onMetadataInventoryPut(self,pos)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos)
 	self:triggerIfNeeded(pos)
 end
 function industrialtest.SimpleElectricItemProcessor.onMetadataInventoryTake(self,pos,listname,index,stack)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryTake(self,pos,listname,index,stack)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local srcSlot=inv:get_stack("src",1)
 	local dstSlot=inv:get_stack("dst",1)
 	if listname=="src" and srcSlot:is_empty() then
 		meta:set_float("srcTime",-1)
 		meta:set_float("maxSrcTime",0)
 		self:updateFormspec(pos)
 	elseif listname=="dst" and dstSlot:get_free_space()>0 then
 		self:triggerIfNeeded(pos)
 	end
 end
 function industrialtest.SimpleElectricItemProcessor.register(self)
 	industrialtest.ActivatedElectricMachine.register(self)
 	industrialtest.api.addTag(self.name,"simpleElectricItemProcessor")
 end
 function industrialtest.SimpleElectricItemProcessor.shouldActivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	if meta:get_float("maxSrcTime")>0 and meta:get_float("srcTime")>=0 then
 		return false
 	end
 	-- TODO: Take elapsed time into account
 	local requiredPower=self.opPower*industrialtest.api.getMachineSpeed(meta)
 	if meta:get_int("industrialtest.powerAmount")<requiredPower then
 		return false
 	end
 	local srcSlot=inv:get_stack("src",1)
 	if srcSlot:get_count()>0 then
 		local output=self:getCraftResult(srcSlot)
 		return output and output.time>0 and inv:room_for_item("dst",output.item)
 	end
 	return false
 end
 function industrialtest.SimpleElectricItemProcessor.shouldDeactivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	-- TODO: Take elapsed time into account
 	local requiredPower=self.opPower*industrialtest.api.getMachineSpeed(meta)
 	if meta:get_int("industrialtest.powerAmount")<requiredPower then
 		return true
 	end
 	local srcSlot=inv:get_stack("src",1)
 	if srcSlot:is_empty() then
 		return true
 	end
 	local output=self:getCraftResult(srcSlot)
 	return not output or output.time==0 or not inv:room_for_item("dst",output.item)
 end
 function industrialtest.SimpleElectricItemProcessor.activeUpdate(self,pos,elapsed,meta,inv)
 	local srcSlot=inv:get_stack("src",1)
 	local srcTime=0
 	local maxSrcTime
 	if meta:get_float("maxSrcTime")<=0 then
 		local output=self:getCraftResult(srcSlot)
 		maxSrcTime=output.time*self.efficiency
 		meta:set_float("srcTime",0)
 		meta:set_float("maxSrcTime",maxSrcTime)
 		shouldUpdateFormspec=true
 	else
 		srcTime=meta:get_float("srcTime")
 		maxSrcTime=meta:get_float("maxSrcTime")
 	end
 	local speed=industrialtest.api.getMachineSpeed(meta)
 	local requiredPower=elapsed*self.opPower*speed
 	industrialtest.api.addPower(meta,-requiredPower)
 	srcTime=srcTime+elapsed
 	meta:set_int("srcTime",srcTime)
 	if srcTime>=maxSrcTime then
 		local output=self:getCraftResult(srcSlot)
 		local usedItems=srcSlot:get_count()-output.src:get_count()
 		local multiplier=1
 		if srcSlot:get_count()>=speed*usedItems then
 			multiplier=speed
 		end
 		if output.item:get_count()>0 then
 			output.item:set_count(output.item:get_count()*multiplier)
 			inv:add_item("dst",output.item)
 		end
 		meta:set_float("srcTime",-1)
 		meta:set_float("maxSrcTime",0)
 		srcSlot:set_count(srcSlot:get_count()-multiplier*usedItems)
 		inv:set_stack("src",1,srcSlot)
 	end
 	return true
 end
 function industrialtest.SimpleElectricItemProcessor.getCraftResult(self,itemstack)
 	-- Dummy method
 end
--- a/machines/solar_panel_generator.lua
+++ b/machines/solar_panel_generator.lua
@@ -15,93 +15,86 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-local solarPanel={}
+industrialtest.SolarPanelBase=table.copy(industrialtest.ElectricMachine)
-
+industrialtest.internal.unpackTableInto(industrialtest.SolarPanelBase,{
-solarPanel.getFormspec=function(pos)
+	sounds="metal",
-	local amount=minetest.get_natural_light(vector.offset(pos,0,1,0))/15.0
+	requiresWrench=true,
-	local charging=amount>0.5
+	storageLists={
-	local formspec
+		"charged"
-	if industrialtest.mtgAvailable then
+	},
-		formspec={
+	powerLists={
-			"list[context;charged;4.9,1.8;1,1]",
+		{
-			"listring[context;charged]",
+			list="charged",
-			(charging and "image[4.9,2.8;1,1;industrialtest_gui_sun_fg.png]"
+			direction="o"
 			 or "image[4.9,2.8;1,1;industrialtest_gui_sun_bg.png]")
 		}
-	elseif industrialtest.mclAvailable then
+	},
-		formspec={
+	hasPowerOutput=true,
-			"list[context;charged;4.7,1.8;1,1]",
+	ioConfig="oooooo"
-			mcl_formspec.get_itemslot_bg(4.7,1.8,1,1),
+})
 			"listring[context;charged]",
 			(charging and "image[4.7,2.8;1,1;industrialtest_gui_sun_fg.png]"
 			 or "image[4.7,2.8;1,1;industrialtest_gui_sun_bg.png]")
 		}
 	end
 	return table.concat(formspec,"")
 end
-solarPanel.onConstruct=function(pos,meta,inv)
+local solarPanels={}
 function industrialtest.SolarPanelBase.onConstruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	inv:set_size("charged",1)
 	meta:set_float("prevAmount",0)
 	industrialtest.ElectricMachine.onConstruct(self,pos)
 end
-solarPanel.onTimer=function(pos,elapsed,meta,inv,config)
+function industrialtest.SolarPanelBase.getFormspec(self,pos)
-	local chargedSlot=inv:get_stack("charged",1)
+	local parentFormspec=industrialtest.ElectricMachine.getFormspec(self,pos)
-	local shouldUpdateFormspec=false
+	local amount=minetest.get_natural_light(vector.offset(pos,0,1,0))/15.0
 	local charging=amount>0.5
 	local formspec={
 		"list[context;charged;4.7,1.8;1,1]",
 		industrialtest.internal.getItemSlotBg(4.7,1.8,1,1),
 		(charging and "image[4.7,2.8;1,1;industrialtest_gui_sun_fg.png]"
 		 or "image[4.7,2.8;1,1;industrialtest_gui_sun_bg.png]"),
 		"listring[context;charged]"
 	}
 	return parentFormspec..table.concat(formspec,"")
 end
 function industrialtest.SolarPanelBase.register(self)
 	industrialtest.ElectricMachine.register(self)
 	table.insert(solarPanels,self.name)
 end
 function industrialtest.SolarPanelBase.action(self,pos)
 	local meta=minetest.get_meta(pos)
 	local amount=minetest.get_natural_light(vector.offset(pos,0,1,0))/15.0
 	local charging=amount>0.5
 	if charging then
-		industrialtest.api.addPower(meta,math.ceil(amount*config.flow*elapsed))
+		if industrialtest.api.addPower(meta,math.ceil(amount*self.flow))>0 then
-	end
+			self:updateFormspec(pos)
 	if meta:get_int("industrialtest.powerAmount")>0 then
 		if chargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(chargedSlot:get_meta()) then
 			industrialtest.api.transferPowerToItem(meta,chargedSlot,math.ceil(config.flow*elapsed))
 			inv:set_stack("charged",1,chargedSlot)
 		end
-		industrialtest.api.powerFlow(pos)
+		self:trigger(pos)
 	end
 	if amount~=meta:get_float("prevAmount") then
-		shouldUpdateFormspec=true
+		self:updateFormspec(pos)
 		meta:set_float("prevAmount",amount)
 	end
 	return true,shouldUpdateFormspec
 end
-local function registerSolarPanelGenerator(config)
+industrialtest.SolarPanel=table.copy(industrialtest.SolarPanelBase)
-	industrialtest.internal.registerMachine({
+industrialtest.internal.unpackTableInto(industrialtest.SolarPanel,{
-		name=config.name,
+	name="industrialtest:solar_panel",
-		displayName=config.displayName,
+	description=S("Solar Panel"),
-		getFormspec=solarPanel.getFormspec,
+	tiles={
-		capacity=config.capacity,
+		"industrialtest_machine_block.png^industrialtest_solar_panel_top.png",
-		flow=config.flow,
+		"industrialtest_machine_block.png",
-		ioConfig="oooooo",
+		"industrialtest_machine_block.png",
-		requiresWrench=true,
+		"industrialtest_machine_block.png",
-		registerActiveVariant=false,
+		"industrialtest_machine_block.png",
-		powerSlots={"charged"},
+		"industrialtest_machine_block.png"
-		storageSlots={"charged"},
+	},
 		sounds="metal",
 		groups={
 			_industrialtest_hasPowerOutput=1
 		},
 		customKeys={
 			tiles={
 				"industrialtest_machine_block.png^industrialtest_"..config.name.."_top.png",
 				"industrialtest_machine_block.png"
 			}
 		},
 		onConstruct=solarPanel.onConstruct,
 		onTimer=function(pos,elapsed,meta,inv)
 			return solarPanel.onTimer(pos,elapsed,meta,inv,config)
 		end
 	})
 end
 registerSolarPanelGenerator({
 	name="solar_panel",
 	displayName=S("Solar Panel"),
 	capacity=industrialtest.api.lvPowerFlow*2,
 	flow=industrialtest.api.lvPowerFlow
 })
 industrialtest.SolarPanel:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:solar_panel",
@@ -112,12 +105,24 @@ minetest.register_craft({
 	}
 })
-registerSolarPanelGenerator({
+industrialtest.LVSolarArray=table.copy(industrialtest.SolarPanelBase)
-	name="lv_solar_array",
+industrialtest.internal.unpackTableInto(industrialtest.LVSolarArray,{
-	displayName=S("LV Solar Array"),
+	name="industrialtest:lv_solar_array",
 	description=S("LV Solar Array"),
 	tiles={
 		"industrialtest_machine_block.png^industrialtest_lv_solar_array_top.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png"
 	},
 	capacity=industrialtest.api.lvPowerFlow*4,
 	flow=industrialtest.api.lvPowerFlow*2
 })
 industrialtest.LVSolarArray:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:lv_solar_array",
@@ -128,12 +133,24 @@ minetest.register_craft({
 	}
 })
-registerSolarPanelGenerator({
+industrialtest.MVSolarArray=table.copy(industrialtest.SolarPanelBase)
-	name="mv_solar_array",
+industrialtest.internal.unpackTableInto(industrialtest.MVSolarArray,{
-	displayName=S("MV Solar Array"),
+	name="industrialtest:mv_solar_array",
 	description=S("MV Solar Array"),
 	tiles={
 		"industrialtest_machine_block.png^industrialtest_mv_solar_array_top.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png"
 	},
 	capacity=industrialtest.api.mvPowerFlow*2,
 	flow=industrialtest.api.mvPowerFlow
 })
 industrialtest.MVSolarArray:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:mv_solar_array",
@@ -144,12 +161,25 @@ minetest.register_craft({
 	}
 })
-registerSolarPanelGenerator({
+
-	name="hv_solar_array",
+industrialtest.HVSolarArray=table.copy(industrialtest.SolarPanelBase)
-	displayName=S("HV Solar Array"),
+industrialtest.internal.unpackTableInto(industrialtest.HVSolarArray,{
 	name="industrialtest:hv_solar_array",
 	description=S("HV Solar Array"),
 	tiles={
 		"industrialtest_machine_block.png^industrialtest_hv_solar_array_top.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png"
 	},
 	capacity=industrialtest.api.hvPowerFlow*2,
 	flow=industrialtest.api.hvPowerFlow
 })
 industrialtest.HVSolarArray:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:hv_solar_array",
@@ -159,3 +189,14 @@ minetest.register_craft({
 		{"industrialtest:mv_solar_array","industrialtest:mv_solar_array","industrialtest:mv_solar_array"}
 	}
 })
 minetest.register_abm({
 	name="Solar panel updating",
 	nodenames=solarPanels,
 	interval=industrialtest.updateDelay,
 	chance=1,
 	action=function(pos,node)
 		local def=minetest.registered_nodes[node.name]
 		def._industrialtest_self:action(pos)
 	end
 })
--- a/machines/tool_workshop.lua
+++ b/machines/tool_workshop.lua
@@ -15,170 +15,33 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-local toolWorkshop={}
+industrialtest.ToolWorkshop=table.copy(industrialtest.ActivatedElectricMachine)
-
+industrialtest.internal.unpackTableInto(industrialtest.ToolWorkshop,{
-toolWorkshop.getFormspec=function(pos)
+	name="industrialtest:tool_workshop",
-	local meta=minetest.get_meta(pos)
+	description=S("Tool Workshop"),
-	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
+	tiles={
-	local formspec
+		"industrialtest_advanced_machine_block.png",
-	if industrialtest.mtgAvailable then
+		"industrialtest_advanced_machine_block.png",
-		formspec={
+		"industrialtest_advanced_machine_block.png",
-			"list[context;powerStorage;3.7,3.7;1,1;0]",
+		"industrialtest_advanced_machine_block.png",
-			"listring[context;powerStorage]",
+		"industrialtest_advanced_machine_block.png",
-			(powerPercent>0 and "image[3.7,2.5;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
+		"industrialtest_advanced_machine_block.png^industrialtest_tool_workshop_front.png",
-			 or "image[3.7,2.5;1,1;industrialtest_gui_electricity_bg.png]"),
+	},
 			"list[context;tool;5.9,3.2;1,1;0]",
 			"listring[context;tool]",
 			"list[context;upgrades;9,0.9;1,4]",
 			"listring[context;upgrades]"
 		}
 	elseif industrialtest.mclAvailable then
 		formspec={
 			"list[context;powerStorage;3.7,3.7;1,1;0]",
 			mcl_formspec.get_itemslot_bg(3.7,3.7,1,1),
 			"listring[context;powerStorage]",
 			(powerPercent>0 and "image[3.7,2.5;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
 			 or "image[3.7,2.5;1,1;industrialtest_gui_electricity_bg.png]"),
 			"list[context;tool;5.9,3.2;1,1;0]",
 			mcl_formspec.get_itemslot_bg(5.9,3.2,1,1),
 			"listring[context;tool]",
 			"list[context;upgrades;9,0.9;1,4]",
 			mcl_formspec.get_itemslot_bg(9,0.9,1,4),
 			"listring[context;upgrades]"
 		}
 	end
 	return table.concat(formspec,"")
 end
 toolWorkshop.onConstruct=function(pos,meta,inv)
 	inv:set_size("powerStorage",1)
 	inv:set_size("tool",1)
 	inv:set_size("upgrades",4)
 end
 toolWorkshop.onTimer=function(pos,elapsed,meta,inv)
 	local powerStorageSlot=inv:get_stack("powerStorage",1)
 	local toolSlot=inv:get_stack("tool",1)
 	local requiredPower=industrialtest.api.getMachineSpeed(meta)*10000
 	local shouldRerunTimer=false
 	local shouldUpdateFormspec=false
 	if powerStorageSlot:get_count()>0 then
 		local stackMeta=powerStorageSlot:get_meta()
 		if industrialtest.api.transferPower(stackMeta,meta,stackMeta:get_int("industrialtest.powerFlow"))>0 then
 			shouldUpdateFormspec=true
 			shouldRerunTimer=true
 			industrialtest.api.updateItemPowerText(powerStorageSlot)
 			inv:set_stack("powerStorage",1,powerStorageSlot)
 		end
 	end
 	if toolSlot:get_count()>0 and toolSlot:get_wear()>0 and meta:get_int("industrialtest.powerAmount")>=requiredPower then
 		minetest.swap_node(pos,{
 			name="industrialtest:tool_workshop_active",
 			param2=minetest.get_node(pos).param2
 		})
 		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
 	return shouldRerunTimer,shouldUpdateFormspec
 end
 toolWorkshop.activeOnTimer=function(pos,elapsed,meta,inv)
 	local powerStorageSlot=inv:get_stack("powerStorage",1)
 	local toolSlot=inv:get_stack("tool",1)
 	local speed=industrialtest.api.getMachineSpeed(meta)
 	local requiredPower=speed*10000
 	local shouldRerunTimer=false
 	local shouldUpdateFormspec=false
 	if powerStorageSlot:get_count()>0 then
 		local stackMeta=powerStorageSlot:get_meta()
 		if industrialtest.api.transferPower(stackMeta,meta,stackMeta:get_int("industrialtest.powerFlow"))>0 then
 			shouldUpdateFormspec=true
 			shouldRerunTimer=true
 			industrialtest.api.updateItemPowerText(powerStorageSlot)
 			inv:set_stack("powerStorage",1,powerStorageSlot)
 		end
 	end
 	if toolSlot:get_count()>0 and toolSlot:get_wear()>0 and meta:get_int("industrialtest.powerAmount")>=requiredPower then
 		local removed=math.min(toolSlot:get_wear(),speed*200)
 		toolSlot:set_wear(toolSlot:get_wear()-removed)
 		inv:set_stack("tool",1,toolSlot)
 		industrialtest.api.addPower(meta,-requiredPower)
 		shouldRerunTimer=true
 		shouldUpdateFormspec=true
 	else
 		minetest.swap_node(pos,{
 			name="industrialtest:tool_workshop",
 			param2=minetest.get_node(pos).param2
 		})
 	end
 	return shouldRerunTimer,shouldUpdateFormspec
 end
 local function isTool(stack)
 	local def=minetest.registered_tools[stack:get_name()]
 	if not def or industrialtest.api.hasPowerStorage(stack:get_meta())then
 		return false
 	end
 	return def.groups and (def.groups.pickaxe or def.groups.sword or def.groups.hoe or def.groups.tool or def.groups.weapon or def.groups.shovel or def.groups.axe)
 end
 toolWorkshop.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
 	if toList=="tool" then
 		local meta=minetest.get_meta(pos)
 		local inv=meta:get_inventory()
 		local movedItemStack=inv:get_stack(fromList,fromIndex)
 		if not isTool(movedItemStack) then
 			return 0
 		end
 	end
 	return count
 end
 toolWorkshop.allowMetadataInventoryPut=function(pos,listname,index,stack)
 	if listname=="tool" and not isTool(stack) then
 		return 0
 	end
 	return stack:get_count()
 end
 toolWorkshop.metadataChange=function(pos)
 	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 end
 industrialtest.internal.registerMachine({
 	name="tool_workshop",
 	displayName=S("Tool Workshop"),
 	getFormspec=toolWorkshop.getFormspec,
 	capacity=20000,
 	flow=industrialtest.api.hvPowerFlow,
 	ioConfig="iiiiii",
 	requiresWrench=true,
 	registerActiveVariant=true,
 	powerSlots={"powerStorage"},
 	storageSlots={"tool"},
 	sounds="metal",
-	groups={
+	requiresWrench=true,
-		_industrialtest_hasPowerInput=1
+	facedir=true,
 	storageLists={
 		"src",
 		"upgrades",
 		"powerStorage"
 	},
-	customKeys={
+	powerLists={
-		tiles={
+		{
-			"industrialtest_advanced_machine_block.png",
+			list="powerStorage",
-			"industrialtest_advanced_machine_block.png",
+			direction="i"
-			"industrialtest_advanced_machine_block.png",
+		}
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png^industrialtest_tool_workshop_front.png",
 			"industrialtest_advanced_machine_block.png"
 		},
 		paramtype2="facedir",
 		legacy_facedir_simple=true
 	},
-	activeCustomKeys={
+	active={
 		tiles={
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
@@ -186,17 +49,112 @@ industrialtest.internal.registerMachine({
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png",
 			"industrialtest_advanced_machine_block.png^industrialtest_tool_workshop_front_active.png",
-			"industrialtest_advanced_machine_block.png"
+		}
 		},
 	},
-	onConstruct=toolWorkshop.onConstruct,
+	capacity=15000,
-	onTimer=toolWorkshop.onTimer,
+	flow=industrialtest.api.hvPowerFlow,
-	activeOnTimer=toolWorkshop.activeOnTimer,
+	hasPowerInput=true,
-	allowMetadataInventoryMove=toolWorkshop.allowMetadataInventoryMove,
+	ioConfig="iiiiii",
-	allowMetadataInventoryPut=toolWorkshop.allowMetadataInventoryPut,
+	_opPower=10000,
-	onMetadataInventoryPut=toolWorkshop.metadataChange,
+	_efficiency=200
 	onMetadataInventoryMove=toolWorkshop.metadataChange
 })
 function industrialtest.ToolWorkshop.onConstruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	inv:set_size("powerStorage",1)
 	inv:set_size("src",1)
 	inv:set_size("upgrades",4)
 	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
 end
 function industrialtest.ToolWorkshop.getFormspec(self,pos)
 	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
 	local formspec={
 		"list[context;powerStorage;3.7,3.7;1,1;0]",
 		industrialtest.internal.getItemSlotBg(3.7,3.7,1,1),
 		(powerPercent>0 and "image[3.7,2.5;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
 		 or "image[3.7,2.5;1,1;industrialtest_gui_electricity_bg.png]"),
 		"list[context;src;5.9,3.2;1,1;0]",
 		industrialtest.internal.getItemSlotBg(5.9,3.2,1,1),
 		"list[context;upgrades;9,0.9;1,4]",
 		industrialtest.internal.getItemSlotBg(9,0.9,1,4),
 		"listring[context;src]"
 	}
 	return parentFormspec..table.concat(formspec,"")
 end
 function industrialtest.ToolWorkshop.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	if toList=="src" then
 		local meta=minetest.get_meta(pos)
 		local inv=meta:get_inventory()
 		local movedItemStack=inv:get_stack(fromList,fromIndex)
 		if not self.isTool(movedItemStack) then
 			return 0
 		end
 	end
 	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 end
 function industrialtest.ToolWorkshop.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
 	if listname=="tool" and not self.isTool(stack) then
 		return 0
 	end
 	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
 end
 function industrialtest.ToolWorkshop.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 	self:triggerIfNeeded(pos)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 end
 function industrialtest.ToolWorkshop.onMetadataInventoryPut(self,pos,listname,index,stack)
 	self:triggerIfNeeded(pos)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
 end
 function industrialtest.ToolWorkshop.shouldActivate(self,pos)
 	local meta=minetest.get_meta(pos)
 	local requiredPower=industrialtest.api.getMachineSpeed(meta)*self._opPower
 	if meta:get_int("industrialtest.powerAmount")<requiredPower then
 		return false
 	end
 	local inv=meta:get_inventory()
 	local toolSlot=inv:get_stack("src",1)
 	return not toolSlot:is_empty() and self.isTool(toolSlot) and toolSlot:get_wear()>0
 end
 function industrialtest.ToolWorkshop.shouldDeactivate(self,pos)
 	return not self:shouldActivate(pos)
 end
 function industrialtest.ToolWorkshop.activeUpdate(self,pos,elapsed,meta,inv)
 	local toolSlot=inv:get_stack("src",1)
 	local speed=industrialtest.api.getMachineSpeed(meta)
 	local requiredPower=industrialtest.api.getMachineSpeed(meta)*self._opPower
 	local removed=math.min(toolSlot:get_wear(),speed*self._efficiency)
 	toolSlot:set_wear(toolSlot:get_wear()-removed)
 	inv:set_stack("src",1,toolSlot)
 	industrialtest.api.addPower(meta,-requiredPower)
 	return true
 end
 function industrialtest.ToolWorkshop.isTool(stack)
 	local def=minetest.registered_tools[stack:get_name()]
 	if not def or industrialtest.api.hasPowerStorage(stack:get_meta())then
 		return false
 	end
 	return def.groups and (def.groups.pickaxe or def.groups.sword or def.groups.hoe or def.groups.tool or def.groups.weapon or def.groups.shovel or def.groups.axe)
 end
 industrialtest.ToolWorkshop:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:tool_workshop",
--- a/machines/transformer.lua
+++ b/machines/transformer.lua
@@ -15,81 +15,70 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-local transformer={}
+industrialtest.Transformer=table.copy(industrialtest.ElectricMachine)
-
+industrialtest.internal.unpackTableInto(industrialtest.Transformer,{
-transformer.onPowerFlow=function(pos,side,amount)
+	withoutFormspec=true,
-	local normalized=industrialtest.api.normalizeSide(pos,side)
+	facedir=true,
-	local def=minetest.registered_nodes[minetest.get_node(pos).name]
+	storageLists={},
-	if normalized~=5 and amount>=def._industrialtest_lowerFlow then
+	powerLists={},
-		minetest.remove_node(pos)
+	hasPowerInput=true,
-		industrialtest.internal.explode(pos,2)
+	hasPowerOutput=true
 	end
 end
 transformer.onTimer=function(pos,elapsed,meta)
 	local powerAmount=meta:get_int("industrialtest.powerAmount")
 	local def=minetest.registered_nodes[minetest.get_node(pos).name]
 	local afterFlowLower=false
 	local afterFlowUpper=false
 	if powerAmount>=def._industrialtest_lowerFlow then
 		afterFlowLower,_=industrialtest.api.powerFlow(pos,{
 			[1]=true,
 			[2]=true,
 			[3]=true,
 			[4]=true,
 			[6]=true
 		},def._industrialtest_lowerFlow)
 	end
 	if powerAmount>=def._industrialtest_upperFlow then
 		afterFlowUpper,_=industrialtest.api.powerFlow(pos,{[5]=true},def._industrialtest_upperFlow)
 	end
 	return powerAmount>0 and (afterFlowLower or afterFlowUpper),false
 end
 local function registerTransformer(config)
 	industrialtest.internal.registerMachine({
 		name=config.name,
 		displayName=config.displayName,
 		capacity=industrialtest.api.ivPowerFlow,
 		flow=industrialtest.api.ivPowerFlow,
 		ioConfig="aaaaaa",
 		storageSlots={},
 		powerSlots={},
 		sounds=config.sounds,
 		groups={
 			_industrialtest_hasPowerOutput=1,
 			_industrialtest_hasPowerInput=1,
 		},
 		customKeys={
 			tiles={
 				config.machineBlockTexture.."^industrialtest_"..config.name.."_side.png",
 				config.machineBlockTexture.."^industrialtest_"..config.name.."_side.png",
 				config.machineBlockTexture.."^industrialtest_"..config.name.."_side.png",
 				config.machineBlockTexture.."^industrialtest_"..config.name.."_side.png",
 				config.machineBlockTexture.."^industrialtest_"..config.name.."_side.png",
 				config.machineBlockTexture.."^industrialtest_"..config.name.."_front.png"
 			},
 			paramtype2="facedir",
 			legacy_facedir_simple=true,
 			_industrialtest_lowerFlow=config.lowerFlow,
 			_industrialtest_upperFlow=config.upperFlow,
 			_industrialtest_onPowerFlow=transformer.onPowerFlow
 		},
 		requiresWrench=config.requiresWrench,
 		withoutFormspec=true,
 		onTimer=transformer.onTimer
 	})
 end
 registerTransformer({
 	name="lv_transformer",
 	displayName=S("LV Transformer"),
 	machineBlockTexture="industrialtest_wood_machine_block.png",
 	requiresWrench=false,
 	lowerFlow=industrialtest.api.lvPowerFlow,
 	upperFlow=industrialtest.api.mvPowerFlow,
 	sounds="wood"
 })
 function industrialtest.Transformer.register(self)
 	self.ioConfig={
 		{
 			mode="a",
 			flow=self.lowerFlow
 		},
 		{
 			mode="a",
 			flow=self.lowerFlow
 		},
 		{
 			mode="a",
 			flow=self.lowerFlow
 		},
 		{
 			mode="a",
 			flow=self.lowerFlow
 		},
 		{
 			mode="a",
 			flow=self.flow
 		},
 		{
 			mode="a",
 			flow=self.lowerFlow
 		}
 	}
 	industrialtest.ElectricMachine.register(self)
 end
 function industrialtest.Transformer.onPowerFlow(self,pos)
 	self:trigger(pos)
 end
 industrialtest.LVTransformer=table.copy(industrialtest.Transformer)
 industrialtest.internal.unpackTableInto(industrialtest.LVTransformer,{
 	name="industrialtest:lv_transformer",
 	description=S("LV Transformer"),
 	sounds="wood",
 	tiles={
 		"industrialtest_wood_machine_block.png^industrialtest_lv_transformer_side.png",
 		"industrialtest_wood_machine_block.png^industrialtest_lv_transformer_side.png",
 		"industrialtest_wood_machine_block.png^industrialtest_lv_transformer_side.png",
 		"industrialtest_wood_machine_block.png^industrialtest_lv_transformer_side.png",
 		"industrialtest_wood_machine_block.png^industrialtest_lv_transformer_side.png",
 		"industrialtest_wood_machine_block.png^industrialtest_lv_transformer_front.png"
 	},
 	capacity=industrialtest.api.mvPowerFlow,
 	flow=industrialtest.api.mvPowerFlow,
 	lowerFlow=industrialtest.api.lvPowerFlow
 })
 industrialtest.LVTransformer:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:lv_transformer",
@@ -100,15 +89,27 @@ minetest.register_craft({
 	}
 })
-registerTransformer({
+industrialtest.MVTransformer=table.copy(industrialtest.Transformer)
-	name="mv_transformer",
+industrialtest.internal.unpackTableInto(industrialtest.MVTransformer,{
-	displayName=S("MV Transformer"),
+	name="industrialtest:mv_transformer",
-	machineBlockTexture="industrialtest_machine_block.png",
+	description=S("MV Transformer"),
 	sounds="metal",
 	requiresWrench=true,
-	lowerFlow=industrialtest.api.mvPowerFlow,
+	tiles={
-	upperFlow=industrialtest.api.hvPowerFlow,
+		"industrialtest_machine_block.png^industrialtest_mv_transformer_side.png",
-	sounds="metal"
+		"industrialtest_machine_block.png^industrialtest_mv_transformer_side.png",
 		"industrialtest_machine_block.png^industrialtest_mv_transformer_side.png",
 		"industrialtest_machine_block.png^industrialtest_mv_transformer_side.png",
 		"industrialtest_machine_block.png^industrialtest_mv_transformer_side.png",
 		"industrialtest_machine_block.png^industrialtest_mv_transformer_front.png"
 	},
 	capacity=industrialtest.api.hvPowerFlow,
 	flow=industrialtest.api.hvPowerFlow,
 	lowerFlow=industrialtest.api.mvPowerFlow
 })
 industrialtest.MVTransformer:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:mv_transformer",
@@ -119,15 +120,27 @@ minetest.register_craft({
 	}
 })
-registerTransformer({
+industrialtest.HVTransformer=table.copy(industrialtest.Transformer)
-	name="hv_transformer",
+industrialtest.internal.unpackTableInto(industrialtest.HVTransformer,{
-	displayName=S("HV Transformer"),
+	name="industrialtest:hv_transformer",
-	machineBlockTexture="industrialtest_machine_block.png",
+	description=S("HV Transformer"),
 	sounds="metal",
 	requiresWrench=true,
-	lowerFlow=industrialtest.api.hvPowerFlow,
+	tiles={
-	upperFlow=industrialtest.api.evPowerFlow,
+		"industrialtest_machine_block.png^industrialtest_hv_transformer_side.png",
-	sounds="metal"
+		"industrialtest_machine_block.png^industrialtest_hv_transformer_side.png",
 		"industrialtest_machine_block.png^industrialtest_hv_transformer_side.png",
 		"industrialtest_machine_block.png^industrialtest_hv_transformer_side.png",
 		"industrialtest_machine_block.png^industrialtest_hv_transformer_side.png",
 		"industrialtest_machine_block.png^industrialtest_hv_transformer_front.png"
 	},
 	capacity=industrialtest.api.evPowerFlow,
 	flow=industrialtest.api.evPowerFlow,
 	lowerFlow=industrialtest.api.hvPowerFlow
 })
 industrialtest.HVTransformer:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:hv_transformer",
@@ -138,15 +151,27 @@ minetest.register_craft({
 	}
 })
-registerTransformer({
+industrialtest.EVTransformer=table.copy(industrialtest.Transformer)
-	name="ev_transformer",
+industrialtest.internal.unpackTableInto(industrialtest.EVTransformer,{
-	displayName=S("EV Transformer"),
+	name="industrialtest:ev_transformer",
-	machineBlockTexture="industrialtest_machine_block.png",
+	description=S("EV Transformer"),
 	sounds="metal",
 	requiresWrench=true,
-	lowerFlow=industrialtest.api.evPowerFlow,
+	tiles={
-	upperFlow=industrialtest.api.ivPowerFlow,
+		"industrialtest_machine_block.png^industrialtest_ev_transformer_side.png",
-	sounds="metal"
+		"industrialtest_machine_block.png^industrialtest_ev_transformer_side.png",
 		"industrialtest_machine_block.png^industrialtest_ev_transformer_side.png",
 		"industrialtest_machine_block.png^industrialtest_ev_transformer_side.png",
 		"industrialtest_machine_block.png^industrialtest_ev_transformer_side.png",
 		"industrialtest_machine_block.png^industrialtest_ev_transformer_front.png"
 	},
 	capacity=industrialtest.api.ivPowerFlow,
 	flow=industrialtest.api.ivPowerFlow,
 	lowerFlow=industrialtest.api.evPowerFlow
 })
 industrialtest.EVTransformer:register()
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:ev_transformer",
--- a/machines/wind_mill.lua
+++ b/machines/wind_mill.lua
@@ -15,40 +15,60 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 local S=minetest.get_translator("industrialtest")
-local windMill={}
+industrialtest.WindMill=table.copy(industrialtest.ElectricMachine)
 industrialtest.internal.unpackTableInto(industrialtest.WindMill,{
 	name="industrialtest:wind_mill",
 	description=S("Wind Mill"),
 	tiles={
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png",
 		"industrialtest_machine_block.png^industrialtest_wind_mill_side.png",
 		"industrialtest_machine_block.png^industrialtest_wind_mill_side.png",
 		"industrialtest_machine_block.png^industrialtest_wind_mill_side.png",
 		"industrialtest_machine_block.png^industrialtest_wind_mill_side.png"
 	},
 	sounds="metal",
 	requiresWrench=true,
 	storageLists={
 		"charged"
 	},
 	powerLists={
 		{
 			list="charged",
 			direction="o"
 		}
 	},
 	capacity=7000,
 	flow=industrialtest.api.lvPowerFlow,
 	hasPowerOutput=true,
 	ioConfig="oooooo",
 })
-windMill.getFormspec=function(pos)
+function industrialtest.WindMill.onConstruct(self,pos)
 	local meta=minetest.get_meta(pos)
-	local charging=meta:get_int("charging")
+	local inv=meta:get_inventory()
 	local formspec
 	if industrialtest.mtgAvailable then
 		formspec={
 			"list[context;charged;4.9,1.8;1,1]",
 			"listring[context;charged]",
 			(charging>0 and "image[4.9,3;1,1;industrialtest_gui_wind_bg.png^[lowpart:"..charging..":industrialtest_gui_wind_fg.png]"
 			 or "image[4.9,3;1,1;industrialtest_gui_wind_bg.png]")
 		}
 	elseif industrialtest.mclAvailable then
 		formspec={
 			"list[context;charged;4.7,1.8;1,1]",
 			mcl_formspec.get_itemslot_bg(4.7,1.8,1,1),
 			"listring[context;charged]",
 			(charging>0 and "image[4.7,3;1,1;industrialtest_gui_wind_bg.png^[lowpart:"..charging..":industrialtest_gui_wind_fg.png]"
 			 or "image[4.7,3;1,1;industrialtest_gui_wind_bg.png]")
 		}
 	end
 	return table.concat(formspec,"")
 end
 windMill.onConstruct=function(pos,meta,inv)
 	inv:set_size("charged",1)
 	meta:set_int("prevCharging",0)
 	meta:set_int("charging",0)
 	industrialtest.ElectricMachine.onConstruct(self,pos)
 end
-windMill.onTimer=function(pos,elapsed,meta,inv)
+function industrialtest.WindMill.getFormspec(self,pos)
-	local chargedSlot=inv:get_stack("charged",1)
+	local parentFormspec=industrialtest.ElectricMachine.getFormspec(self,pos)
-	local shouldUpdateFormspec=false
+	local meta=minetest.get_meta(pos)
 	local charging=meta:get_int("charging")
 	local formspec={
 		"list[context;charged;4.7,1.8;1,1]",
 		industrialtest.internal.getItemSlotBg(4.7,1.8,1,1),
 		(charging>0 and "image[4.7,3;1,1;industrialtest_gui_wind_bg.png^[lowpart:"..charging..":industrialtest_gui_wind_fg.png]"
 		 or "image[4.7,3;1,1;industrialtest_gui_wind_bg.png]"),
 		"listring[context;charged]"
 	}
 	return parentFormspec..table.concat(formspec,"")
 end
 function industrialtest.WindMill.action(self,pos)
 	local meta=minetest.get_meta(pos)
 	local charging
 	if industrialtest.mtgAvailable then
 		charging=math.min(math.max(pos.y,0)/150,1.0)
@@ -77,48 +97,17 @@ windMill.onTimer=function(pos,elapsed,meta,inv)
 			break
 		end
 	end
-	industrialtest.api.addPower(meta,math.ceil(charging*elapsed*industrialtest.api.lvPowerFlow))
+	if industrialtest.api.addPower(meta,math.ceil(charging*industrialtest.api.lvPowerFlow))>0 then
 		self:trigger(pos)
 	end
 	if meta:get_int("prevCharging")~=charging then
-		shouldUpdateFormspec=true
+		meta:set_int("prevCharging",charging)
 		self:updateFormspec(pos)
 	end
 	if chargedSlot:get_count()>0 and meta:get_int("industrialtest.powerAmount")>0 then
 		if industrialtest.api.transferPowerToItem(meta,chargedSlot,industrialtest.api.lvPowerFlow)>0 then
 			inv:set_stack("charged",1,chargedSlot)
 		end
 	end
 	industrialtest.api.powerFlow(pos)
 	meta:set_int("charging",charging*100)
 	return true,shouldUpdateFormspec
 end
-industrialtest.internal.registerMachine({
+industrialtest.WindMill:register()
 	name="wind_mill",
 	displayName=S("Wind Mill"),
 	getFormspec=windMill.getFormspec,
 	capacity=7000,
 	flow=industrialtest.api.lvPowerFlow,
 	ioConfig="oooooo",
 	requiresWrench=true,
 	registerActiveVariant=false,
 	powerSlots={"charged"},
 	storageSlots={"charged"},
 	sounds="metal",
 	groups={
 		_industrialtest_hasPowerOutput=1
 	},
 	customKeys={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_wind_mill_side.png",
 			"industrialtest_machine_block.png^industrialtest_wind_mill_side.png",
 			"industrialtest_machine_block.png^industrialtest_wind_mill_side.png",
 			"industrialtest_machine_block.png^industrialtest_wind_mill_side.png"
 		}
 	},
 	onConstruct=windMill.onConstruct,
 	onTimer=windMill.onTimer
 })
 minetest.register_craft({
 	type="shaped",
@@ -129,3 +118,13 @@ minetest.register_craft({
 		{"","industrialtest:refined_iron_ingot",""}
 	}
 })
 minetest.register_abm({
 	name="Wind mill updating",
 	nodenames={"industrialtest:wind_mill"},
 	interval=industrialtest.updateDelay,
 	chance=1,
 	action=function(pos)
 		industrialtest.WindMill:action(pos)
 	end
 })
--- a/mapgen.lua
+++ b/mapgen.lua
@@ -15,12 +15,12 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 minetest.register_on_generated(function(minp,maxp,seed)
-	if industrialtest.random:next(1,100)>40 then
+	if industrialtest.mods.mclRubber or industrialtest.random:next(1,100)>40 then
 		return
 	end
 	local center=vector.new((maxp.x-minp.x)/2+ minp.x,(maxp.y-minp.y)/2+minp.y,(maxp.z-minp.z)/2+minp.z)
 	local pos=minetest.find_node_near(center,maxp.x-minp.x,{industrialtest.elementKeys.grassBlock})
 	if pos then
-		industrialtest.makeRubberTree(pos)
+		industrialtest.internal.makeRubberTree(pos)
 	end
 end)
--- a/minerals.lua
+++ b/minerals.lua
@@ -15,25 +15,51 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 if industrialtest.mtgAvailable then
-	industrialtest.registerMetal("uranium","Uranium",3)
+	industrialtest.internal.registerMetal("uranium","Uranium",3)
 	minetest.register_ore({
 		ore_type="scatter",
 		ore="industrialtest:stone_with_uranium",
 		wherein="default:stone",
-		clust_scarcity=7*7*7,
+		clust_scarcity=15*15*15,
 		clust_num_ores=3,
 		clust_size=3,
 		y_max=-128,
 		y_min=-31000
 	})
 	industrialtest.internal.registerMetal("lead","Lead",2)
 	minetest.register_ore({
 		ore_type="scatter",
 		ore="industrialtest:stone_with_lead",
 		wherein="default:stone",
 		clust_scarcity=11*11*11,
 		clust_num_ores=3,
 		clust_size=3,
 		y_max=-48,
 		y_min=-31000
 	})
 	industrialtest.internal.registerMetal("iridium","Iridium",3)
 	minetest.register_ore({
 		ore_type="scatter",
 		ore="industrialtest:stone_with_iridium",
 		wherein="default:stone",
 		clust_scarcity=40*40*40,
 		clust_num_ores=3,
 		clust_size=3,
 		y_max=-512,
 		y_min=-31000
 	})
 elseif industrialtest.mclAvailable then
 	industrialtest.registerMetal("uranium","Uranium",4,4,4,4,5,5)
 	local stonelike={"mcl_core:stone","mcl_core:diorite","mcl_core:andesite","mcl_core:granite"}
 	local deepslatelike={"mcl_deepslate:deepslate","mcl_deepslate:tuff"}
 	industrialtest.internal.registerMetal("uranium","Uranium",4,4,4,4,5,5)
 	minetest.register_ore({
 		ore_type="scatter",
 		ore="industrialtest:stone_with_uranium",
 		wherein=stonelike,
-		clust_scarcity=7*7*7,
+		clust_scarcity=15*15*15,
 		clust_num_ores=3,
 		clust_size=3,
 		y_max=mcl_worlds.layer_to_y(20),
@@ -42,8 +68,52 @@ elseif industrialtest.mclAvailable then
 	minetest.register_ore({
 		ore_type="scatter",
 		ore="industrialtest:deepslate_with_uranium",
-		wherein={"mcl_deepslate:deepslate","mcl_deepslate:tuff"},
+		wherein=deepslatelike,
-		clust_scarcity=7*7*7,
+		clust_scarcity=15*15*15,
 		clust_num_ores=3,
 		clust_size=3,
 		y_max=mcl_worlds.layer_to_y(15),
 		y_min=mcl_vars.mg_overworld_min
 	})
 	industrialtest.internal.registerMetal("lead","Lead",4,4,4,4,6,5)
 	minetest.register_ore({
 		ore_type="scatter",
 		ore="industrialtest:stone_with_lead",
 		wherein=stonelike,
 		clust_scarcity=11*11*11,
 		clust_num_ores=3,
 		clust_size=3,
 		y_max=mcl_worlds.layer_to_y(30),
 		y_min=mcl_vars.mg_overworld_min
 	})
 	minetest.register_ore({
 		ore_type="scatter",
 		ore="industrialtest:deepslate_with_lead",
 		wherein=deepslatelike,
 		clust_scarcity=11*11*11,
 		clust_num_ores=3,
 		clust_size=3,
 		y_max=mcl_worlds.layer_to_y(15),
 		y_min=mcl_vars.mg_overworld_min
 	})
 	industrialtest.internal.registerMetal("iridium","Iridium",4,5,4,4,5,5)
 	minetest.register_ore({
 		ore_type="scatter",
 		ore="industrialtest:stone_with_iridium",
 		wherein=stonelike,
 		clust_scarcity=40*40*40,
 		clust_num_ores=3,
 		clust_size=3,
 		y_max=mcl_worlds.layer_to_y(20),
 		y_min=mcl_vars.mg_overworld_min
 	})
 	minetest.register_ore({
 		ore_type="scatter",
 		ore="industrialtest:deepslate_with_iridium",
 		wherein=deepslatelike,
 		clust_scarcity=40*40*40,
 		clust_num_ores=3,
 		clust_size=3,
 		y_max=mcl_worlds.layer_to_y(15),
--- a/mod.conf
+++ b/mod.conf
@@ -1,5 +1,5 @@
 name=industrialtest
 description=Adds various machinery
-optional_depends=default,bucket,3d_armor,mcl_core,mcl_copper,mcl_armor,mcl_deepslate,mcl_nether,mcl_buckets
+optional_depends=default,bucket,3d_armor,mcl_core,mcl_copper,mcl_armor,mcl_deepslate,mcl_nether,mcl_buckets,mcl_util,mcl_dye,mcl_rubber,pipeworks,logistica,mesecons
 author=IndustrialTest Team
-title=IndustrialTest
+title=IndustrialTest
--- a/nodes.lua
+++ b/nodes.lua
@@ -66,309 +66,430 @@ minetest.register_craft({
 	}
 })
-definition={
+if not industrialtest.mods.mclRubber then
-	description=S("Rubber Wood"),
+	definition={
-	tiles={
+		description=S("Rubber Wood"),
-		"industrialtest_rubber_wood_top.png",
+		tiles={
-		"industrialtest_rubber_wood_top.png",
+			"industrialtest_rubber_wood_top.png",
-		"industrialtest_rubber_wood_side.png"
+			"industrialtest_rubber_wood_top.png",
-	},
+			"industrialtest_rubber_wood_side.png"
-	paramtype2="4dir"
+		},
-}
+		paramtype2="4dir"
 if industrialtest.mtgAvailable then
 	definition.sounds=default.node_sound_wood_defaults()
 	definition.groups={
 		tree=1,
 		choppy=2,
 		oddly_breakable_by_hand=1,
 		flammable=2
 	}
-elseif industrialtest.mclAvailable then
+	if industrialtest.mtgAvailable then
-	definition.sounds=mcl_sounds.node_sound_wood_defaults()
+		definition.sounds=default.node_sound_wood_defaults()
-	definition.groups={
+		definition.groups={
-		handy=1,
+			tree=1,
-		axey=1,
+			choppy=2,
-		tree=1,
+			oddly_breakable_by_hand=1,
-		flammable=2,
+			flammable=2
 		building_block=1,
 		material_wood=1,
 		fire_encouragement=5,
 		fire_flammability=5
 	}
 	definition.after_destruct=mcl_core.update_leaves
 	definition._mcl_blast_resistance=1.8
 	definition._mcl_hardness=1.8
 end
 definition.groups._industrialtest_rubberWood=1
 minetest.register_node("industrialtest:rubber_wood",definition)
 definition=table.copy(definition)
 definition.description=nil
 definition.tiles={
 	"industrialtest_rubber_wood_top.png",
 	"industrialtest_rubber_wood_top.png",
 	"industrialtest_rubber_wood_side.png",
 	"industrialtest_rubber_wood_side.png",
 	"industrialtest_rubber_wood_side_with_rubber.png",
 	"industrialtest_rubber_wood_side.png"
 }
 definition.drop="industrialtest:rubber_wood"
 if industrialtest.mclAvailable then
 	definition.groups.not_in_creative_inventory=1
 	definition._doc_items_create_entry=false
 end
 minetest.register_node("industrialtest:rubber_wood_with_rubber",definition)
 minetest.register_abm({
 	label="Rubber forming",
 	nodenames={"industrialtest:rubber_wood"},
 	interval=120,
 	chance=2,
 	action=function(pos)
 		local neighbourPositions={
 			vector.offset(pos,-1,0,0),
 			vector.offset(pos,1,0,0),
 			vector.offset(pos,0,-1,0),
 			vector.offset(pos,0,1,0),
 			vector.offset(pos,0,0,-1),
 			vector.offset(pos,0,0,1)
 		}
-		for _,value in ipairs(neighbourPositions) do
+	elseif industrialtest.mclAvailable then
-			if minetest.get_node(value).name=="industrialtest:rubber_wood_with_rubber" then
+		definition.sounds=mcl_sounds.node_sound_wood_defaults()
-				return
+		definition.groups={
-			end
+			handy=1,
-		end
+			axey=1,
-		minetest.set_node(pos,{
+			tree=1,
-			name="industrialtest:rubber_wood_with_rubber",
+			flammable=2,
-			param2=industrialtest.random:next(0,3)
+			building_block=1,
-		})
+			material_wood=1,
 			fire_encouragement=5,
 			fire_flammability=5
 		}
 		definition.after_destruct=mcl_core.update_leaves
 		definition._mcl_blast_resistance=1.8
 		definition._mcl_hardness=1.8
 	end
-})
+	definition.groups._industrialtest_rubberWood=1
-minetest.register_craft({
+	minetest.register_node("industrialtest:rubber_wood",definition)
-	type="shapeless",
+	definition=table.copy(definition)
-	output=industrialtest.elementKeys.junglePlanks.." 3",
+	definition.description=nil
-	recipe={"group:_industrialtest_rubberWood"}
+	definition.tiles={
-})
+		"industrialtest_rubber_wood_top.png",
-definition={
+		"industrialtest_rubber_wood_top.png",
-	description=S("Rubber Leaves"),
+		"industrialtest_rubber_wood_side.png",
-	drawtype="allfaces_optional",
+		"industrialtest_rubber_wood_side.png",
-	tiles={"industrialtest_rubber_leaves.png"},
+		"industrialtest_rubber_wood_side_with_rubber.png",
-	special_tiles={"industrialtest_rubber_leaves_simple.png"},
+		"industrialtest_rubber_wood_side.png"
 	paramtype="light",
 	sunlight_propagates=true,
 	waving=1
 }
 if industrialtest.mtgAvailable then
 	definition.sounds=default.node_sound_leaves_defaults()
 	definition.groups={
 		snappy=3,
 		leafdecay=3,
 		flammable=2,
 		leaves=1
 	}
-	definition.drop={
+	definition.drop="industrialtest:rubber_wood"
-		max_items=1,
+	if industrialtest.mclAvailable then
-		items={
+		definition.groups.not_in_creative_inventory=1
-			{
+		definition._doc_items_create_entry=false
-				items={"industrialtest:rubber_sapling"},
+	end
-				rarity=20
+	minetest.register_node("industrialtest:rubber_wood_with_rubber",definition)
-			},
+	minetest.register_abm({
-			{items={"industrialtest:rubber_leaves"}}
+			label="Rubber forming",
 			nodenames={"industrialtest:rubber_wood"},
 			interval=120,
 			chance=2,
 			action=function(pos)
 				local neighbourPositions={
 					vector.offset(pos,-1,0,0),
 					vector.offset(pos,1,0,0),
 					vector.offset(pos,0,-1,0),
 					vector.offset(pos,0,1,0),
 					vector.offset(pos,0,0,-1),
 					vector.offset(pos,0,0,1)
 				}
 				for _,value in ipairs(neighbourPositions) do
 					if minetest.get_node(value).name=="industrialtest:rubber_wood_with_rubber" then
 						return
 					end
 				end
 				minetest.set_node(pos,{
 					name="industrialtest:rubber_wood_with_rubber",
 					param2=industrialtest.random:next(0,3)
 				})
 			end
 	})
 	minetest.register_craft({
 		type="shapeless",
 		output=industrialtest.elementKeys.junglePlanks.." 3",
 		recipe={"group:_industrialtest_rubberWood"}
 	})
 	definition={
 		description=S("Rubber Leaves"),
 		drawtype="allfaces_optional",
 		tiles={"industrialtest_rubber_leaves.png"},
 		special_tiles={"industrialtest_rubber_leaves_simple.png"},
 		paramtype="light",
 		sunlight_propagates=true,
 		waving=1
 	}
 	if industrialtest.mtgAvailable then
 		definition.sounds=default.node_sound_leaves_defaults()
 		definition.groups={
 			snappy=3,
 			leafdecay=3,
 			flammable=2,
 			leaves=1
 		}
-	}
+		definition.drop={
 	definition.after_place_node=default.after_place_leaves
 elseif industrialtest.mclAvailable then
 	local saplingChances={20,16,12,10}
 	local stickChances={50,45,30,35,10}
 	-- Taken and adapted from https://git.minetest.land/MineClone2/MineClone2/src/branch/master/mods/ITEMS/mcl_core/nodes_trees.lua#L157
 	local function getDrops(fortuneLevel)
 		local drop = {
 			max_items=1,
-			items = {
+			items={
 				{
-					items = {"industrialtest:rubber_sapling"},
+					items={"industrialtest:rubber_sapling"},
-					rarity = saplingChances[fortuneLevel+1] or saplingChances[fortuneLevel]
+					rarity=20
 				},
 				{
 					items = {"mcl_core:stick 1"},
 					rarity = stickChances[fortuneLevel+1]
 				},
 				{
 					items = {"mcl_core:stick 2"},
 					rarity = stickChances[fortuneLevel+1]
 				},
 				{items={"industrialtest:rubber_leaves"}}
 			}
 		}
-		return drop
+		definition.after_place_node=default.after_place_leaves
 	elseif industrialtest.mclAvailable then
 		local saplingChances={20,16,12,10}
 		local stickChances={50,45,30,35,10}
 		-- Taken and adapted from https://git.minetest.land/MineClone2/MineClone2/src/branch/master/mods/ITEMS/mcl_core/nodes_trees.lua#L157
 		local function getDrops(fortuneLevel)
 			local drop = {
 				max_items=1,
 				items = {
 					{
 						items = {"industrialtest:rubber_sapling"},
 						rarity = saplingChances[fortuneLevel+1] or saplingChances[fortuneLevel]
 					},
 					{
 						items = {"mcl_core:stick 1"},
 						rarity = stickChances[fortuneLevel+1]
 					},
 					{
 						items = {"mcl_core:stick 2"},
 						rarity = stickChances[fortuneLevel+1]
 					},
 				}
 			}
 			return drop
 		end
 		definition.sounds=mcl_sounds.node_sound_leaves_defaults()
 		definition.groups={
 			handy=1,
 			hoey=1,
 			shearsy=1,
 			swordy=1,
 			dig_by_piston=1,
 			flammable=2,
 			fire_encouragement=30,
 			fire_flammability=60,
 			leaves=1,
 			deco_block=1,
 			compostability=30
 		}
 		definition.drop=getDrops(0)
 		definition.after_place_node=mcl_core.make_player_leaves
 		definition._mcl_shears_drop=true
 		definition._mcl_blast_resistance=0.2
 		definition._mcl_hardness=0.2
 		definition._mcl_silk_touch_drop=true
 		definition._mcl_fortune_drop={getDrops(1),getDrops(2),getDrops(3),getDrops(4)}
 	end
-	definition.sounds=mcl_sounds.node_sound_leaves_defaults()
+	minetest.register_node("industrialtest:rubber_leaves",definition)
-	definition.groups={
+	if industrialtest.mtgAvailable then
-		handy=1,
+		default.register_leafdecay({
-		hoey=1,
+			trunks={"industrialtest:rubber_wood"},
-		shearsy=1,
+			leaves={"industrialtest:rubber_leaves"},
-		swordy=1,
+			radius=2
-		dig_by_piston=1,
+		})
-		flammable=2,
+	end
-		fire_encouragement=30,
+	if industrialtest.mclAvailable then
-		fire_flammability=60,
+		definition=table.copy(definition)
-		leaves=1,
+		definition._doc_items_create_entry=false
-		deco_block=1,
+		definition.groups.not_in_creative_inventory=1
-		compostability=30
+		definition.groups.orphan_leaves=1
-	}
+		definition._mcl_shears_drop={"industrialtest:rubber_leaves"}
-	definition.drop=getDrops(0)
+		definition._mcl_silk_touch_drop={"industrialtest:rubber_leaves"}
-	definition.after_place_node=mcl_core.make_player_leaves
+		minetest.register_node("industrialtest:rubber_leaves_orphan",definition)
-	definition._mcl_shears_drop=true
+	end
-	definition._mcl_blast_resistance=0.2
+	industrialtest.internal.makeRubberTree=function(pos)
-	definition._mcl_hardness=0.2
+		-- FIXME: Replace this with placing schematic
-	definition._mcl_silk_touch_drop=true
+		-- Taken and adapted from https://github.com/minetest/minetest_game/blob/master/mods/default/trees.lua#L182
-	definition._mcl_fortune_drop={getDrops(1),getDrops(2),getDrops(3),getDrops(4)}
+		local height=industrialtest.random:next(4,5)
-end
+		local tree=minetest.get_content_id("industrialtest:rubber_wood")
-minetest.register_node("industrialtest:rubber_leaves",definition)
+		local treeWithRubber=minetest.get_content_id("industrialtest:rubber_wood_with_rubber")
-if industrialtest.mtgAvailable then
+		local leaves=minetest.get_content_id("industrialtest:rubber_leaves")
-	default.register_leafdecay({
+		local air=minetest.get_content_id("air")
-		trunks={"industrialtest:rubber_wood"},
+		local ignore=minetest.get_content_id("ignore")
 		leaves={"industrialtest:rubber_leaves"},
 		radius=2
 	})
 end
 if industrialtest.mclAvailable then
 	definition=table.copy(definition)
 	definition._doc_items_create_entry=false
 	definition.groups.not_in_creative_inventory=1
 	definition.groups.orphan_leaves=1
 	definition._mcl_shears_drop={"industrialtest:rubber_leaves"}
 	definition._mcl_silk_touch_drop={"industrialtest:rubber_leaves"}
 	minetest.register_node("industrialtest:rubber_leaves_orphan",definition)
 end
 industrialtest.makeRubberTree=function(pos)
 	-- FIXME: Replace this with placing schematic
 	-- Taken and adapted from https://github.com/minetest/minetest_game/blob/master/mods/default/trees.lua#L182
 	local height=industrialtest.random:next(4,5)
 	local tree=minetest.get_content_id("industrialtest:rubber_wood")
 	local treeWithRubber=minetest.get_content_id("industrialtest:rubber_wood_with_rubber")
 	local leaves=minetest.get_content_id("industrialtest:rubber_leaves")
 	local air=minetest.get_content_id("air")
 	local ignore=minetest.get_content_id("ignore")
-	local manip=minetest.get_voxel_manip()
+		local manip=minetest.get_voxel_manip()
-	local minp,maxp=manip:read_from_map(vector.new(pos.x-2,pos.y,pos.z),vector.new(pos.x+2,pos.y+height+1,pos.z+2))
+		local minp,maxp=manip:read_from_map(vector.new(pos.x-2,pos.y,pos.z),vector.new(pos.x+2,pos.y+height+1,pos.z+2))
-	local area=VoxelArea:new({
+		local area=VoxelArea:new({
 			MinEdge=minp,
 			MaxEdge=maxp
-	})
+		})
-	local data=manip:get_data()
+		local data=manip:get_data()
-	-- Trunk
+		-- Trunk
-	data[area:index(pos.x,pos.y,pos.z)]=tree
+		data[area:index(pos.x,pos.y,pos.z)]=tree
-	for y=pos.y+1,pos.y+height-1 do
+		for y=pos.y+1,pos.y+height-1 do
-		local index=area:index(pos.x,y,pos.z)
+			local index=area:index(pos.x,y,pos.z)
-		local id=data[index]
+			local id=data[index]
-		if id==air or id==ignore or id==leaves then
+			if id==air or id==ignore or id==leaves then
-			data[index]=(industrialtest.random:next(0,5)==1 and treeWithRubber or tree)
+				data[index]=(industrialtest.random:next(0,5)==1 and treeWithRubber or tree)
 		end
 	end
 	-- Force leaves near the trunk
 	for dz=-1,1 do
 		for dy=-2,1 do
 			local index=area:index(pos.x-1,pos.y+height+dy,pos.z+dz)
 			for dx=-1,1 do
 				if data[index]==air or data[index]==ignore then
 					data[index]=leaves
 				end
 				index=index+1
 			end
 		end
-	end
+		-- Force leaves near the trunk
-	-- Randomly add leaves in 2x2x2 clusters.
+		for dz=-1,1 do
-	for i=1,8 do
+			for dy=-2,1 do
-		local x=pos.x+industrialtest.random:next(-2,1)
+				local index=area:index(pos.x-1,pos.y+height+dy,pos.z+dz)
-		local y=pos.y+height+industrialtest.random:next(-2,0)
+				for dx=-1,1 do
 		local z=pos.z+industrialtest.random:next(-2,1)
 		for dx=0,1 do
 			for dy=0,1 do
 				for dz=0,1 do
 					local index=area:index(x+dx,y+dy,z+dz)
 					if data[index]==air or data[index]==ignore then
 						data[index]=leaves
 					end
 					index=index+1
 				end
 			end
 		end
 		-- Randomly add leaves in 2x2x2 clusters.
 		for i=1,8 do
 			local x=pos.x+industrialtest.random:next(-2,1)
 			local y=pos.y+height+industrialtest.random:next(-2,0)
 			local z=pos.z+industrialtest.random:next(-2,1)
 			for dx=0,1 do
 				for dy=0,1 do
 					for dz=0,1 do
 						local index=area:index(x+dx,y+dy,z+dz)
 						if data[index]==air or data[index]==ignore then
 							data[index]=leaves
 						end
 					end
 				end
 			end
 		end
 		manip:set_data(data)
 		manip:write_to_map()
 		manip:update_map()
 	end
-
+	definition={
-	manip:set_data(data)
+		description=S("Rubber Sapling"),
-	manip:write_to_map()
+		inventory_image="industrialtest_rubber_sapling.png",
-	manip:update_map()
+		wield_image="industrialtest_rubber_sapling.png",
-end
+		drawtype="plantlike",
-definition={
+		tiles={"industrialtest_rubber_sapling.png"},
-	description=S("Rubber Sapling"),
+		paramtype="light",
-	inventory_image="industrialtest_rubber_sapling.png",
+		sunlight_propagates=true,
-	wield_image="industrialtest_rubber_sapling.png",
+		walkable=false,
-	drawtype="plantlike",
+		waving=1
 	tiles={"industrialtest_rubber_sapling.png"},
 	paramtype="light",
 	sunlight_propagates=true,
 	walkable=false,
 	waving=1,
 	on_timer=function(pos)
 		-- Use MTG can_grow function if available
 		local canGrow
 		if industrialtest.mtgAvailable then
 			canGrow=default.can_grow
 		elseif industrialtest.mclAvailable then
 			canGrow=function(pos)
 				local under=minetest.get_node_or_nil(vector.offset(pos,0,-1,0))
 				if not under then
 					return false
 				end
 				local lightLevel=minetest.get_node_light(pos)
 				return (minetest.get_item_group(under.name,"soil")>0 and lightLevel and lightLevel>=13)
 			end
 		end
 		if not canGrow(pos) then
 			minetest.get_node_timer(pos):start(300)
 			return false
 		end
 		industrialtest.makeRubberTree(pos)
 		return false
 	end
 }
 if industrialtest.mtgAvailable then
 	definition.sounds=default.node_sound_leaves_defaults()
 	definition.groups={
 		snappy=2,
 		flammable=2
 	}
-	definition.on_construct=function(pos)
+	if industrialtest.mtgAvailable then
-		minetest.get_node_timer(pos):start(industrialtest.random:next(300,1500))
+		definition.sounds=default.node_sound_leaves_defaults()
-	end
+		definition.groups={
-elseif industrialtest.mclAvailable then
+			snappy=2,
-	definition.sounds=mcl_sounds.node_sound_leaves_defaults()
+			flammable=2
-	definition.groups={
+		}
-		plant=1,
+		definition.on_construct=function(pos)
 		non_mycelium_plant=1,
 		deco_block=1,
 		dig_by_water=1,
 		dig_by_piston=1,
 		destroy_by_lava_flow=1,
 		compostability=40
 	}
 	definition.on_construct=function(pos)
 		local meta=minetest.get_meta(pos)
 		meta:set_int("stage",0)
 	end
 end
 definition.groups.attached_node=1
 definition.groups.dig_immediate=3
 definition.groups.sapling=1
 minetest.register_node("industrialtest:rubber_sapling",definition)
 if industrialtest.mtgAvailable then
 	minetest.register_lbm({
 		name="industrialtest:rubber_sapling_lbm",
 		nodenames={"industrialtest:rubber_sapling"},
 		action=function(pos)
 			minetest.get_node_timer(pos):start(industrialtest.random:next(300,1500))
 		end
-	})
+		definition.on_timer=function(pos)
 			if not default.can_grow(pos) then
 				minetest.get_node_timer(pos):start(300)
 				return false
 			end
 			industrialtest.internal.makeRubberTree(pos)
 			return false
 		end
 	elseif industrialtest.mclAvailable then
 		definition.sounds=mcl_sounds.node_sound_leaves_defaults()
 		definition.groups={
 			plant=1,
 			non_mycelium_plant=1,
 			deco_block=1,
 			dig_by_water=1,
 			dig_by_piston=1,
 			destroy_by_lava_flow=1,
 			compostability=40
 		}
 		definition.on_construct=function(pos)
 			local meta=minetest.get_meta(pos)
 			meta:set_int("stage",0)
 		end
 		definition.on_place=mcl_util.generate_on_place_plant_function(function(pos,node)
 			local nodeBelow = minetest.get_node_or_nil(vector.new(pos.x,pos.y-1,pos.z))
 			if not nodeBelow then
 				return false
 			end
 			local name = nodeBelow.name
 			return minetest.get_item_group(name,"grass_block")==1 or
 					name=="mcl_core:podzol" or name=="mcl_core:podzol_snow" or
 					name=="mcl_core:dirt" or name=="mcl_core:mycelium" or name=="mcl_core:coarse_dirt"
 		end)
 		minetest.register_abm({
 			label="Rubber sapling growing",
 			nodenames={"industrialtest:rubber_sapling"},
 			interval=120,
 			chance=1,
 			catch_up=false,
 			action=function(pos)
 				local under=minetest.get_node_or_nil(vector.offset(pos,0,-1,0))
 				if not under or minetest.get_item_group(under.name,"soil")==0 then
 					return
 				end
 				local lightLevel=minetest.get_node_light(pos)
 				if not lightLevel or lightLevel<13 then
 					return
 				end
 				local meta=minetest.get_meta(pos)
 				local stage=meta:get_int("stage") or 0
 				stage=stage+1
 				if stage>=3 then
 					industrialtest.internal.makeRubberTree(pos)
 				else
 					meta:set_int("stage",stage)
 				end
 			end
 		})
 		mcl_dye.register_on_bone_meal_apply(function(pointed)
 			local node=minetest.get_node(pointed.under)
 			if node.name~="industrialtest:rubber_sapling" then
 				return
 			end
 			if industrialtest.random:next(1,100)>45 then
 				return
 			end
 			local meta=minetest.get_meta(pointed.under)
 			local stage=meta:get_int("stage") or 0
 			stage=stage+1
 			if stage>=3 then
 					industrialtest.internal.makeRubberTree(pointed.under)
 			else
 				meta:set_int("stage",stage)
 			end
 		end)
 	end
 	definition.groups.attached_node=1
 	definition.groups.dig_immediate=3
 	definition.groups.sapling=1
 	minetest.register_node("industrialtest:rubber_sapling",definition)
 	if industrialtest.mtgAvailable then
 		minetest.register_lbm({
 			name="industrialtest:rubber_sapling_lbm",
 			nodenames={"industrialtest:rubber_sapling"},
 			action=function(pos)
 				minetest.get_node_timer(pos):start(industrialtest.random:next(300,1500))
 			end
 		})
 	end
 end
 definition={
 	description=S("Reinforced Stone"),
 	tiles={"industrialtest_reinforced_stone.png"}
 }
 if industrialtest.mtgAvailable then
 	definition.groups={cracky=3}
 	definition.sounds=default.node_sound_stone_defaults()
 	definition.on_blast=function(pos,intensity)
 		if intensity>20 then
 			minetest.remove_node(pos)
 			minetest.add_item(pos,ItemStack("industrialtest:reinforced_stone"))
 		end
 	end
 elseif industrialtest.mclAvailable then
 	definition.groups={
 		pickaxey=1,
 		stone=1,
 		building_block=1,
 		material_stone=1
 	}
 	definition.sounds=mcl_sounds.node_sound_stone_defaults()
 	definition._mcl_blast_resistance=1200
 	definition._mcl_hardness=5
 end
 minetest.register_node("industrialtest:reinforced_stone",definition)
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:reinforced_stone 8",
 	recipe={
 		{industrialtest.elementKeys.stone,industrialtest.elementKeys.stone,industrialtest.elementKeys.stone},
 		{industrialtest.elementKeys.stone,"industrialtest:advanced_alloy",industrialtest.elementKeys.stone},
 		{industrialtest.elementKeys.stone,industrialtest.elementKeys.stone,industrialtest.elementKeys.stone}
 	}
 })
 definition={
 	description=S("Reinforced Glass"),
 	drawtype="glasslike_framed_optional",
 	tiles={"industrialtest_reinforced_glass.png"},
 	use_texture_alpha="clip",
 	paramtype="light",
 	sunlight_propagates=true
 }
 if industrialtest.mtgAvailable then
 	definition.groups={cracky=3}
 	definition.sounds=default.node_sound_glass_defaults()
 	definition.on_blast=function(pos,intensity)
 		if intensity>10 then
 			minetest.remove_node(pos)
 			minetest.add_item(pos,ItemStack("industrialtest:reinforced_glass"))
 		end
 	end
 elseif industrialtest.mclAvailable then
 	definition.groups={
 		glass=1,
 		building_block=1,
 		material_glass=1
 	}
 	definition.sounds=mcl_sounds.node_sound_glass_defaults()
 	definition._mcl_blast_resistance=15
 	definition._mcl_hardness=1.5
 end
 minetest.register_node("industrialtest:reinforced_glass",definition)
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:reinforced_glass 7",
 	recipe={
 		{industrialtest.elementKeys.glass,industrialtest.elementKeys.glass,industrialtest.elementKeys.glass},
 		{"industrialtest:advanced_alloy",industrialtest.elementKeys.glass,"industrialtest:advanced_alloy"},
 		{industrialtest.elementKeys.glass,industrialtest.elementKeys.glass,industrialtest.elementKeys.glass}
 	}
 })
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:reinforced_glass 7",
 	recipe={
 		{industrialtest.elementKeys.glass,"industrialtest:advanced_alloy",industrialtest.elementKeys.glass},
 		{industrialtest.elementKeys.glass,industrialtest.elementKeys.glass,industrialtest.elementKeys.glass},
 		{industrialtest.elementKeys.glass,"industrialtest:advanced_alloy",industrialtest.elementKeys.glass}
 	}
 })
--- a/sounds/industrialtest_jetpack_loop.ogg
+++ b/sounds/industrialtest_jetpack_loop.ogg
--- a/textures/industrialtest_advanced_electric_chainsaw.png
+++ b/textures/industrialtest_advanced_electric_chainsaw.png
--- a/textures/industrialtest_advanced_electric_drill.png
+++ b/textures/industrialtest_advanced_electric_drill.png
--- a/textures/industrialtest_advanced_electric_hoe.png
+++ b/textures/industrialtest_advanced_electric_hoe.png
--- a/textures/industrialtest_advanced_electric_saber.png
+++ b/textures/industrialtest_advanced_electric_saber.png
--- a/textures/industrialtest_advanced_electronic_circuit.png
+++ b/textures/industrialtest_advanced_electronic_circuit.png
--- a/textures/industrialtest_advanced_re_battery.png
+++ b/textures/industrialtest_advanced_re_battery.png
--- a/textures/industrialtest_batpack_v.png
+++ b/textures/industrialtest_batpack_v.png
--- a/textures/industrialtest_batpack_v_inv.png
+++ b/textures/industrialtest_batpack_v_inv.png
--- a/textures/industrialtest_batpack_v_preview.png
+++ b/textures/industrialtest_batpack_v_preview.png
--- a/textures/industrialtest_canning_machine_front.png
+++ b/textures/industrialtest_canning_machine_front.png
--- a/textures/industrialtest_canning_machine_front_active.png
+++ b/textures/industrialtest_canning_machine_front_active.png
--- a/textures/industrialtest_cell_casing.png
+++ b/textures/industrialtest_cell_casing.png
--- a/textures/industrialtest_cell_fluid.png
+++ b/textures/industrialtest_cell_fluid.png
--- a/textures/industrialtest_chargepad_top.png
+++ b/textures/industrialtest_chargepad_top.png
--- a/textures/industrialtest_chargepad_top_active.png
+++ b/textures/industrialtest_chargepad_top_active.png
--- a/textures/industrialtest_compressed_plantball.png
+++ b/textures/industrialtest_compressed_plantball.png
--- a/textures/industrialtest_coolant_cell.png
+++ b/textures/industrialtest_coolant_cell.png
--- a/textures/industrialtest_dust.png
+++ b/textures/industrialtest_dust.png
--- a/textures/industrialtest_electric_jetpack.png
+++ b/textures/industrialtest_electric_jetpack.png
--- a/textures/industrialtest_electric_jetpack_inv.png
+++ b/textures/industrialtest_electric_jetpack_inv.png
--- a/textures/industrialtest_electric_jetpack_preview.png
+++ b/textures/industrialtest_electric_jetpack_preview.png
--- a/textures/industrialtest_electronic_circuit.png
+++ b/textures/industrialtest_electronic_circuit.png
--- a/textures/industrialtest_empty_cell.png
+++ b/textures/industrialtest_empty_cell.png
--- a/textures/industrialtest_fuel_can.png
+++ b/textures/industrialtest_fuel_can.png
--- a/textures/industrialtest_hydrated_coal.png
+++ b/textures/industrialtest_hydrated_coal.png
--- a/textures/industrialtest_hydrated_coal_dust.png
+++ b/textures/industrialtest_hydrated_coal_dust.png
--- a/textures/industrialtest_iridium_block.png
+++ b/textures/industrialtest_iridium_block.png
--- a/textures/industrialtest_jetpack_v.png
+++ b/textures/industrialtest_jetpack_v.png
--- a/textures/industrialtest_jetpack_v_inv.png
+++ b/textures/industrialtest_jetpack_v_inv.png
--- a/textures/industrialtest_jetpack_v_preview.png
+++ b/textures/industrialtest_jetpack_v_preview.png
--- a/textures/industrialtest_lappack_v.png
+++ b/textures/industrialtest_lappack_v.png
--- a/textures/industrialtest_lappack_v_inv.png
+++ b/textures/industrialtest_lappack_v_inv.png
--- a/textures/industrialtest_lappack_v_preview.png
+++ b/textures/industrialtest_lappack_v_preview.png
--- a/textures/industrialtest_lava_cell.png
+++ b/textures/industrialtest_lava_cell.png
--- a/textures/industrialtest_lead_block.png
+++ b/textures/industrialtest_lead_block.png
--- a/textures/industrialtest_mcl_bronze_boots.png
+++ b/textures/industrialtest_mcl_bronze_boots.png
--- a/textures/industrialtest_mcl_bronze_chestplate.png
+++ b/textures/industrialtest_mcl_bronze_chestplate.png
--- a/textures/industrialtest_mcl_bronze_helmet.png
+++ b/textures/industrialtest_mcl_bronze_helmet.png
--- a/textures/industrialtest_mcl_bronze_leggings.png
+++ b/textures/industrialtest_mcl_bronze_leggings.png
--- a/textures/industrialtest_mcl_iridium_ingot.png
+++ b/textures/industrialtest_mcl_iridium_ingot.png
--- a/textures/industrialtest_mcl_lead_ingot.png
+++ b/textures/industrialtest_mcl_lead_ingot.png
--- a/textures/industrialtest_mcl_nano_boots.png
+++ b/textures/industrialtest_mcl_nano_boots.png
--- a/textures/industrialtest_mcl_quantum_boots.png
+++ b/textures/industrialtest_mcl_quantum_boots.png
--- a/textures/industrialtest_mcl_raw_iridium.png
+++ b/textures/industrialtest_mcl_raw_iridium.png
--- a/textures/industrialtest_mcl_raw_iridium_block.png
+++ b/textures/industrialtest_mcl_raw_iridium_block.png
--- a/textures/industrialtest_mcl_raw_lead.png
+++ b/textures/industrialtest_mcl_raw_lead.png
--- a/textures/industrialtest_mcl_raw_lead_block.png
+++ b/textures/industrialtest_mcl_raw_lead_block.png
--- a/textures/industrialtest_mcl_raw_tin.png
+++ b/textures/industrialtest_mcl_raw_tin.png
--- a/textures/industrialtest_mcl_raw_tin_block.png
+++ b/textures/industrialtest_mcl_raw_tin_block.png
--- a/textures/industrialtest_mcl_raw_uranium.png
+++ b/textures/industrialtest_mcl_raw_uranium.png
--- a/textures/industrialtest_mcl_raw_uranium_block.png
+++ b/textures/industrialtest_mcl_raw_uranium_block.png
--- a/textures/industrialtest_mcl_static_boots.png
+++ b/textures/industrialtest_mcl_static_boots.png
--- a/textures/industrialtest_mcl_stone_with_iridium.png
+++ b/textures/industrialtest_mcl_stone_with_iridium.png
--- a/textures/industrialtest_mcl_stone_with_lead.png
+++ b/textures/industrialtest_mcl_stone_with_lead.png
--- a/Show More
+++ b/Show More