Fix contents scrollbar in guide

TEXTURES_TODO.md

@@ -1,4 +0,0 @@
-# List of textures that still have to be done
-- bronze toolset for MCL
-- bronze nugget for MCL
-- advanced electronic circuit

api/common.lua

@@ -22,6 +22,9 @@ industrialtest.api={
 	geothermalGeneratorFuels={},
 	waterMillFuels={},
 	rotaryMaceratorModifiers={},
+	pumpTargets={},
+	pumpFluids={},
+	compressedFluids={},
 	storageCells={},
 	tags={}
 }
@@ -32,10 +35,21 @@ industrialtest.api.hvPowerFlow=10200
 industrialtest.api.evPowerFlow=40800
 industrialtest.api.ivPowerFlow=163800
 
+industrialtest.api.nodeFluidCapacity=1000
+
 function industrialtest.internal.clamp(num,min,max)
 	return math.max(math.min(num,max),min)
 end
 
+function industrialtest.internal.addYVelocityClamped(player,vel,max)
+	local playerVel=player:get_velocity()
+	if playerVel.y+vel>max then
+		player:add_velocity(vector.new(0,math.max(max-playerVel.y,0),0))
+	else
+		player:add_velocity(vector.new(0,vel,0))
+	end
+end
+
 function industrialtest.internal.unpackTableInto(first,second)
 	for k,v in pairs(second) do
 		first[k]=v

api/fluid.lua

@@ -16,19 +16,23 @@
 
 local S=minetest.get_translator("industrialtest")
 
--- \brief Prepares itemstack containing fluid storage
--- \param itemstack ItemStack
--- \returns bool
-function industrialtest.api.prepareFluidStorageItem(itemstack)
+local function createItemFluidStorageText(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
+	local fluidCapacity=meta:get_int("industrialtest.fluidCapacity")
+	local fluidAmount=meta:get_int("industrialtest.fluidAmount")
+	local lowerLimit=math.floor(fluidCapacity*0.25)
+	local color=(fluidAmount>lowerLimit and "#0000FF" or "#FF0000")
+	return minetest.colorize(color,S("@1 / @2 mB",fluidAmount,fluidCapacity))
+end
+
+-- \brief Adds fluid storage to node metadata
+-- \param meta MetaDataRef
+-- \param capacity number
+-- \returns nil
+function industrialtest.api.addFluidStorage(meta,capacity)
+	meta:set_int("industrialtest.fluidCapacity",capacity)
 	meta:set_int("industrialtest.fluidAmount",0)
-	meta:set_int("industrialtest.fluidCapacity",def._industrialtest_fluidCapacity)
-	industrialtest.api.updateItemFluidText(itemstack)
-	return true
+	meta:set_string("industrialtest.fluidType","ignore")
 end
 
 -- \brief Check if itemstack contains fluid storage
@@ -80,8 +84,13 @@ end
 -- \returns nil
 function industrialtest.api.updateItemFluidText(itemstack)
 	local meta=itemstack:get_meta()
+	if industrialtest.mtgAvailable then
 		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")))
+		local fluidStorageText=createItemFluidStorageText(itemstack)
+		meta:set_string("description",string.format("%s\n%s",def.description,fluidStorageText))
+	elseif industrialtest.mclAvailable then
+		tt.reload_itemstack_description(itemstack)
+	end
 	itemstack:set_wear(65535-meta:get_int("industrialtest.fluidAmount")/meta:get_int("industrialtest.fluidCapacity")*65534)
 end
 
@@ -119,3 +128,15 @@ function industrialtest.api.transferFluidToItem(srcItemstack,itemstack,amount)
 	industrialtest.api.updateItemFluidText(srcItemstack)
 	return actualFlow
 end
+
+if industrialtest.mclAvailable then
+	tt.register_snippet(function(itemstring,toolCapabilities,itemstack)
+		if not itemstack then
+			return nil
+		end
+		if not industrialtest.api.itemHasFluidStorage(itemstack) then
+			return nil
+		end
+		return createItemFluidStorageText(itemstack),false
+	end)
+end

api/network.lua

@@ -41,6 +41,102 @@ local function clampFlow(pos,flow)
 	return math.min(flow,newFlow)
 end
 
+-- \brief Finds path from pos to dest in network. Function finished if either dest is found or every node was visited
+-- \param pos Vector
+-- \param dest Vector
+-- \returns table or nil
+function industrialtest.api.findPathInNetwork(pos,dest)
+	local connections=industrialtest.api.getConnections(pos,"i")
+	if #connections==0 then
+		return nil
+	end
+
+	local workers={}
+	local serializedSourcePos=pos.x..","..pos.y..","..pos.z
+	local visitedNodes={[serializedSourcePos]=true}
+	for _,conn in ipairs(connections) do
+		local sideVector=vector.subtract(conn,pos)
+		table.insert(workers,{
+			position=conn,
+			direction=sideVector,
+			path={[1]=conn}
+		})
+	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] then
+				table.remove(workers,i)
+				break
+			end
+			visitedNodes[serializedPos]=true
+
+			if worker.position.x==dest.x and worker.position.y==dest.y and worker.position.z==dest.z then
+				return worker.path
+			end
+
+			local def=minetest.registered_nodes[minetest.get_node(worker.position).name]
+			if def and def.groups and def.groups._industrialtest_cable then
+				connections=industrialtest.api.getConnections(worker.position,"i")
+				for j=1,#connections do
+					local direction=vector.subtract(connections[j],worker.position)
+					local oppositeDirection=vector.multiply(worker.direction,vector.new(-1,-1,-1))
+					if direction.x~=oppositeDirection.x or direction.y~=oppositeDirection.y or direction.z~=oppositeDirection.z then
+						if worker.direction.x~=direction.x or worker.direction.y~=direction.y or worker.direction.z~=direction.z then
+							table.insert(worker.path,worker.position)
+						end
+						for c=1,#connections do
+							local nextDirection=vector.subtract(connections[c],worker.position)
+							if c~=j and (nextDirection.x~=oppositeDirection.x or nextDirection.y~=oppositeDirection.y or nextDirection.z~=oppositeDirection.z) then
+								local newWorker={
+									position=connections[c],
+									direction=nextDirection,
+									path=table.copy(worker.path)
+								}
+								table.insert(newWorker.path,worker.position)
+								table.insert(workers,newWorker)
+							end
+						end
+						worker.direction=direction
+						worker.position=connections[j]
+						break
+					end
+				end
+
+				if #connections>2 then
+					break
+				end
+			else
+				table.remove(workers,i)
+				break
+			end
+		end
+	end
+
+	return nil
+end
+
+-- \brief Goes through path vertices specified by path running callback on each node.
+--        Function finishes if either callback returns false or entire path is went over.
+-- \param path table
+-- \param callback function
+-- \returns nil
+function industrialtest.api.walkPath(path,callback)
+	local pos=path[1]
+	for i=2,#path do
+		local pathNode=path[i]
+		local direction=vector.normalize(vector.subtract(pathNode,pos))
+		while pos.x~=pathNode.x or pos.y~=pathNode.y or pos.z~=pathNode.z do
+			if not callback(pos) then
+				return
+			end
+			pos=vector.add(pos,direction)
+		end
+	end
+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
@@ -64,11 +160,21 @@ function industrialtest.api.powerFlow(pos,sides,flowOverride)
 	if endpointCount==0 then
 		return false,false
 	end
-	local powerDistribution=math.floor((flowOverride and flowOverride or math.min(meta:get_int("industrialtest.powerAmount"),meta:get_int("industrialtest.powerFlow")))/endpointCount)
+
+	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)
@@ -84,15 +190,43 @@ function industrialtest.api.powerFlow(pos,sides,flowOverride)
 					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)
+					minetest.get_node_timer(endpoint.position):start(industrialtest.config.updateDelay)
 				end
 				if not industrialtest.api.isFullyCharged(endpointMeta) then
 					roomAvailable=true
 				end
 			else
+				local path=industrialtest.api.findPathInNetwork(pos,endpoint.position)
+				if path and #path>0 then
+					table.insert(path,endpoint.position)
+					local removed=false
+					industrialtest.api.walkPath(path,function(pathPos)
+						local def=minetest.registered_nodes[minetest.get_node(pathPos).name]
+						if not def or not def.groups or not def.groups._industrialtest_cable then
+							return false
+						end
+						if powerDistribution>def._industrialtest_cableFlow then
+							removed=true
+							minetest.swap_node(pathPos,{
+								name="air"
+							})
+							minetest.remove_node(pathPos)
+							minetest.check_for_falling(pathPos)
+							minetest.sound_play("default_cool_lava",{
+								pos=pathPos,
+								max_hear_distance=5,
+								gain=0.7
+							})
+						end
+						return true
+					end)
+					if not removed and powerDistribution>endpoint.originalFlow then
 						minetest.remove_node(endpoint.position)
 						industrialtest.internal.explode(endpoint.position,2)
 					end
+					industrialtest.api.createNetworkMapForNode(pos)
+				end
+			end
 		end
 	end
 	return roomAvailable,transferred
@@ -104,12 +238,14 @@ end
 -- \param (optional) omit Vector
 -- \returns table with network map
 function industrialtest.api.createNetworkMap(pos,addCables,omit)
-	local workers={}
 	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,
@@ -122,104 +258,81 @@ function industrialtest.api.createNetworkMap(pos,addCables,omit)
 	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
+			local sourceSide=industrialtest.api.normalizeSide(pos,sides[serializedSideVector])
 			table.insert(workers,{
 				position=conn,
-					targetPosition=conn,
+				direction=sideVector,
 				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])
+				flow=industrialtest.api.getPowerFlowForSide(sourceMeta,sourceSide),
+				sourceSide=sourceSide
 			})
 		end
 	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
-			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
+				end
+				worker.flow=clampFlow(worker.position,worker.flow)
 				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,
+				for i=2,#connections do
+					table.insert(workers,{
+						position=connections[i],
+						direction=vector.subtract(connections[i],worker.position),
 						distance=worker.distance,
-									flow=clampFlow(conn,worker.flow),
-									side=sides[sideVector.x..","..sideVector.y..","..sideVector.z],
+						flow=worker.flow,
 						sourceSide=worker.sourceSide
 					})
-								if #connections==1 then
-									foundNewNode=false
+				end
+				worker.direction=vector.subtract(connections[1],worker.position)
+				worker.position=connections[1]
+				if #connections>=2 then
 					break
 				end
-							end
-						end
-					end
-				end
-				if not foundNewNode then
+			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),
+					originalFlow=flow,
+					side=connectionSide,
+					sourceSide=worker.sourceSide
+				})
 				table.remove(workers,i)
 				break
 			end
-				worker.position=worker.targetPosition
-				worker.flow=worker.targetFlow
-			end
 		end
 	end
+
 	return map
 end
 
@@ -283,6 +396,34 @@ function industrialtest.api.getNetwork(meta)
 	return minetest.deserialize(meta:get_string("industrialtest.network"))
 end
 
+-- \brief Returns amount of power that will flow from specified network master
+-- \param pos Vector
+-- \returns number
+function industrialtest.api.getFlowingCurrent(pos)
+	local meta=minetest.get_meta(pos)
+	if not industrialtest.api.hasPowerStorage(meta) or meta:get_int("industrialtest.powerAmount")==0 then
+		return 0
+	end
+	local network=industrialtest.api.getNetwork(meta)
+	if not network then
+		return 0
+	end
+
+	local amount=meta:get_int("industrialtest.powerAmount")
+	if amount==0 then
+		return 0
+	end
+	local demand=0
+	for _,endpoint in ipairs(network) do
+		local endpointMeta=minetest.get_meta(endpoint.position)
+		if industrialtest.api.hasPowerStorage(endpointMeta) then
+			demand=demand+math.min(endpointMeta:get_int("industrialtest.powerCapacity")-endpointMeta:get_int("industrialtest.powerAmount"),endpoint.flow)
+		end
+	end
+
+	return math.min(amount,demand)
+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
@@ -309,7 +450,7 @@ function industrialtest.api.getConnections(pos,direction)
 		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(normalizedKey))
+			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

api/power.lua

@@ -16,17 +16,29 @@
 
 local S=minetest.get_translator("industrialtest")
 
+local function createItemPowerText(itemstack)
+	local meta=itemstack:get_meta()
+	local powerCapacity=meta:get_int("industrialtest.powerCapacity")
+	local powerAmount=meta:get_int("industrialtest.powerAmount")
+	local lowerLimit=math.floor(powerCapacity*0.25)
+	local color=(powerAmount>lowerLimit and "#00FFFF" or "#FF0000")
+	return minetest.colorize(color,S("@1 / @2 EU",powerAmount,powerCapacity))
+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
+--                 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_string("industrialtest.ioConfig",ioConfig)
+	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
@@ -42,15 +54,49 @@ function industrialtest.api.hasPowerStorage(meta)
 	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=meta:get_string("industrialtest.ioConfig")
+	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
@@ -58,9 +104,13 @@ end
 -- \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=meta:get_string("industrialtest.ioConfig")
+	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
@@ -68,9 +118,13 @@ end
 -- \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=meta:get_string("industrialtest.ioConfig")
+	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
@@ -113,24 +167,15 @@ end
 -- \returns nil
 function industrialtest.api.updateItemPowerText(itemstack)
 	local meta=itemstack:get_meta()
+	if industrialtest.mtgAvailable then
 		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 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
-function industrialtest.api.preparePowerStorageItem(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
+		local powerText=createItemPowerText(itemstack)
+		meta:set_string("description",string.format("%s\n%s",desc,powerText))
+	elseif industrialtest.mclAvailable then
+		tt.reload_itemstack_description(itemstack)
 	end
-	industrialtest.api.addPowerStorage(meta,def._industrialtest_powerCapacity,def._industrialtest_powerFlow,"n/a")
-	industrialtest.api.updateItemPowerText(itemstack)
-	return true
+	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.
@@ -178,3 +223,15 @@ function industrialtest.api.transferPowerFromItem(srcItemstack,meta,amount)
 	return actualFlow
 end
 
+if industrialtest.mclAvailable then
+	tt.register_snippet(function(itemstring,toolCapabilities,itemstack)
+		if not itemstack then
+			return nil
+		end
+		local meta=itemstack:get_meta()
+		if not industrialtest.api.hasPowerStorage(meta) then
+			return nil
+		end
+		return createItemPowerText(itemstack),false
+	end)
+end

api/registration.lua

@@ -272,8 +272,9 @@ end
 
 -- \brief Registers Rotary Macerator recipe modifier
 -- \param config table
+-- \param omitPlaceholder bool, for internal use only
 -- \returns nil
-function industrialtest.api.registerRotaryMaceratorModifier(config)
+function industrialtest.api.registerRotaryMaceratorModifier(config,omitPlaceholder)
 	local definition={
 		name=config.name or "",
 		modifier=config.modifier or "",
@@ -282,6 +283,19 @@ function industrialtest.api.registerRotaryMaceratorModifier(config)
 		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
 
@@ -292,3 +306,77 @@ end
 function industrialtest.api.getRotaryMaceratorModifier(name,modifier)
 	return industrialtest.api.rotaryMaceratorModifiers[name.." "..modifier]
 end
+
+-- \brief Registers target node with which Pump can interact
+-- \param name string
+-- \param fluidNodes table
+-- \param direction string
+-- \return nil
+function industrialtest.api.registerPumpTarget(name,direction)
+	industrialtest.api.pumpTargets[name]={
+		name=name,
+		direction=direction
+	}
+end
+
+-- \brief Returns Pump target info
+-- \param name string
+-- \returns table
+function industrialtest.api.getPumpTarget(name)
+	return industrialtest.api.pumpTargets[name]
+end
+
+-- \brief Registers fluid node which can be pumped by pump
+-- \param name string
+-- \param texture string
+-- \returns nil
+function industrialtest.api.registerPumpFluid(name,texture)
+	industrialtest.api.pumpFluids[name]={
+		name=name,
+		texture=texture
+	}
+end
+
+-- \brief Returns registered node which can be pumped by pump
+-- \param name string
+-- \returns table
+function industrialtest.api.getPumpFluid(name)
+	return industrialtest.api.pumpFluids[name]
+end
+
+-- \brief Registers fluid which can be pumped into compressor resulting with different item
+-- \param fluidType string
+-- \param requiredAmount number
+-- \param time number
+-- \param result string
+-- \returns nil
+function industrialtest.api.registerCompressedFluid(fluidType,requiredAmount,time,result)
+	industrialtest.api.compressedFluids[fluidType]={
+		fluidType=fluidType,
+		requiredAmount=requiredAmount,
+		time=time,
+		result=result
+	}
+end
+
+-- \brief Returns information about fluid which can be pumped into compressor resulting with different item
+-- \param fluidType string
+-- \returns table
+function industrialtest.api.getCompressedFluid(fluidType)
+	return industrialtest.api.compressedFluids[fluidType]
+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)

api/side.lua

@@ -26,13 +26,13 @@ function industrialtest.api.normalizeSide(pos,side)
 			1,2,3,4,5,6
 		},
 		[1]={
-			5,6,3,4,2,1
+			5,6,3,4,1,2
 		},
 		[2]={
 			2,1,3,4,6,5
 		},
 		[3]={
-			6,5,3,4,1,2
+			6,5,3,4,2,1
 		}
 	}
 	if node.param2>3 then

api/tool.lua

@@ -1,60 +0,0 @@
--- 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 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
-function industrialtest.api.prepareToolItem(itemstack)
-	local def=minetest.registered_tools[itemstack:get_name()]
-	if not def then
-		return false
-	end
-	if def._industrialtest_tool and def.tool_capabilities and def.tool_capabilities.uses then
-		local meta=itemstack:get_meta()
-		meta:set_int("industrialtest.uses",def.tool_capabilities.uses)
-		return true
-	elseif def.groups and def.groups._industrialtest_emptyOnConstruct and itemstack:get_wear()==0 then
-		itemstack:set_wear(65534)
-		return true
-	end
-	return false
-end
-
--- \brief Adds wear to item after it's use
--- \param itemstack ItemStack to which wear should be added
--- \returns nil
-function industrialtest.api.afterToolUse(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

cables.lua

@@ -15,27 +15,43 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-local cable={}
 
-cable.onConstruct=function(pos)
+industrialtest.Cable={}
+
+function industrialtest.Cable.onConstruct(self,pos)
 	local connections=industrialtest.api.getConnections(pos)
 	for _,conn in ipairs(connections) do
 		local meta=minetest.get_meta(conn)
 		if industrialtest.api.isNetworkMaster(meta) then
 			industrialtest.api.createNetworkMapForNode(conn)
+			local networkNode=minetest.get_node(conn)
+			local def=minetest.registered_nodes[networkNode.name]
+			if def and def._industrialtest_self then
+				def._industrialtest_self:triggerIfNeeded(conn)
+			else
+				-- Support for bare definitions that don't use industrialtest pseudo-OOP
+				minetest.get_node_timer(conn):start(industrialtest.config.updateDelay)
+			end
 		else
 			local networks=industrialtest.api.isAttachedToNetwork(meta)
 			if networks then
 				for _,network in ipairs(networks) do
 					industrialtest.api.createNetworkMapForNode(network)
-					minetest.get_node_timer(network):start(industrialtest.updateDelay)
+					local networkNode=minetest.get_node(network)
+					local def=minetest.registered_nodes[networkNode.name]
+					if def and def._industrialtest_self then
+						def._industrialtest_self:triggerIfNeeded(network)
+					else
+						-- Support for bare definitions that don't use industrialtest pseudo-OOP
+						minetest.get_node_timer(network):start(industrialtest.config.updateDelay)
+					end
 				end
 			end
 		end
 	end
 end
 
-cable.onDestruct=function(pos)
+function industrialtest.Cable.onDestruct(self,pos)
 	local meta=minetest.get_meta(pos)
 	local networks=industrialtest.api.isAttachedToNetwork(meta)
 	if networks then
@@ -45,14 +61,16 @@ cable.onDestruct=function(pos)
 	end
 end
 
-local function registerCable(name,displayName,size,flow,registerInsulated)
-	local definition={
-		description=S(displayName.." Cable"),
-		inventory_image="industrialtest_"..name.."_cable_inv.png",
-		tiles={"industrialtest_"..name.."_cable.png"},
-		wield_image="industrialtest_"..name.."_cable_inv.png",
+function industrialtest.Cable.createDefinitionTable(self,description,inventoryImage,tile,insulated)
+	local size=(insulated and self.size+0.02 or self.size)
+	local def={
+		description=description,
+		inventory_image=inventoryImage,
+		wield_image=inventoryImage,
+		tiles={tile},
 		paramtype="light",
 		sunlight_propagates=true,
+		use_texture_alpha=(self.transparent and "clip" or "opaque"),
 		drawtype="nodebox",
 		node_box={
 			type="connected",
@@ -118,39 +136,67 @@ local function registerCable(name,displayName,size,flow,registerInsulated)
 			"group:_industrialtest_hasPowerOutput",
 			"group:_industrialtest_cable"
 		},
-		on_construct=cable.onConstruct,
-		on_destruct=cable.onDestruct,
-		_industrialtest_cableFlow=flow
+		on_construct=function(pos)
+			self:onConstruct(pos)
+		end,
+		on_destruct=function(pos)
+			self:onDestruct(pos)
+		end,
+		_industrialtest_cableFlow=self.flow
 	}
+
 	if industrialtest.mtgAvailable then
-		definition.groups={
+		def.groups={
 			cracky=1,
 			level=1,
 			oddly_breakable_by_hand=1
 		}
-		definition.sound=default.node_sound_metal_defaults()
+		def.sound=default.node_sound_metal_defaults()
 	elseif industrialtest.mclAvailable then
-		definition.groups={
+		def.groups={
 			handy=1,
 			pickaxey=1
 		}
-		definition._mcl_blast_resistance=1
-		definition._mcl_hardness=0.5
-		definition.sound=mcl_sounds.node_sound_metal_defaults()
+		def._mcl_blast_resistance=1
+		def._mcl_hardness=0.5
+		def.sound=mcl_sounds.node_sound_metal_defaults()
 	end
-	definition.groups._industrialtest_cable=1
-	minetest.register_node("industrialtest:"..name.."_cable",definition)
-	if registerInsulated then
-		definition=table.copy(definition)
-		definition.description=S("Insulated "..displayName.." Cable")
-		definition.inventory_image="industrialtest_insulated_"..name.."_cable_inv.png"
-		definition.tiles={"industrialtest_insulated_"..name.."_cable.png"}
-		definition.wield_image="industrialtest_insulated_"..name.."_cable_inv.png"
-		minetest.register_node("industrialtest:insulated_"..name.."_cable",definition)
+	def.groups._industrialtest_cable=1
+	if insulated then
+		def.groups._industrialtest_insulatedCable=1
+	end
+
+	return def
+end
+
+function industrialtest.Cable.register(self)
+	local def=self:createDefinitionTable(self.description,self.inventoryImage,self.tile,self.safe)
+	minetest.register_node(self.name,def)
+
+	if self.insulated then
+		def=self:createDefinitionTable(self.insulated.description,self.insulated.inventoryImage,self.insulated.tile,true)
+		minetest.register_node(self.insulated.name,def)
 	end
 end
 
-registerCable("tin","Tin",0.19,industrialtest.api.lvPowerFlow,true)
+industrialtest.TinCable=table.copy(industrialtest.Cable)
+industrialtest.internal.unpackTableInto(industrialtest.TinCable,{
+	name="industrialtest:tin_cable",
+	description=S("Tin Cable"),
+	inventoryImage="industrialtest_tin_cable_inv.png",
+	tile="industrialtest_tin_cable.png",
+	size=0.19,
+	flow=industrialtest.api.lvPowerFlow,
+	insulated={
+		name="industrialtest:insulated_tin_cable",
+		description=S("Insulated Tin Cable"),
+		inventoryImage="industrialtest_insulated_tin_cable_inv.png",
+		tile="industrialtest_insulated_tin_cable.png"
+	}
+})
+
+industrialtest.TinCable:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:tin_cable 6",
@@ -158,6 +204,7 @@ minetest.register_craft({
 		{industrialtest.elementKeys.tinIngot,industrialtest.elementKeys.tinIngot,industrialtest.elementKeys.tinIngot}
 	}
 })
+
 minetest.register_craft({
 	type="shapeless",
 	output="industrialtest:insulated_tin_cable",
@@ -166,6 +213,7 @@ minetest.register_craft({
 		industrialtest.elementKeys.rubber
 	}
 })
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:insulated_tin_cable 6",
@@ -175,13 +223,31 @@ minetest.register_craft({
 		{industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber}
 	}
 })
+
 industrialtest.api.registerCableFormerRecipe({
 	output="industrialtest:tin_cable 12",
 	recipe=industrialtest.elementKeys.tinIngot,
 	time=1
 })
 
-registerCable("copper","Copper",0.15,industrialtest.api.mvPowerFlow,true)
+industrialtest.CopperCable=table.copy(industrialtest.Cable)
+industrialtest.internal.unpackTableInto(industrialtest.CopperCable,{
+	name="industrialtest:copper_cable",
+	description=S("Copper Cable"),
+	inventoryImage="industrialtest_copper_cable_inv.png",
+	tile="industrialtest_copper_cable.png",
+	size=0.15,
+	flow=industrialtest.api.mvPowerFlow,
+	insulated={
+		name="industrialtest:insulated_copper_cable",
+		description=S("Insulated Copper Cable"),
+		inventoryImage="industrialtest_insulated_copper_cable_inv.png",
+		tile="industrialtest_insulated_copper_cable.png"
+	}
+})
+
+industrialtest.CopperCable:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:copper_cable 6",
@@ -189,6 +255,7 @@ minetest.register_craft({
 		{industrialtest.elementKeys.copperIngot,industrialtest.elementKeys.copperIngot,industrialtest.elementKeys.copperIngot}
 	}
 })
+
 minetest.register_craft({
 	type="shapeless",
 	output="industrialtest:insulated_copper_cable",
@@ -197,6 +264,7 @@ minetest.register_craft({
 		industrialtest.elementKeys.rubber
 	}
 })
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:insulated_copper_cable 6",
@@ -206,12 +274,30 @@ minetest.register_craft({
 		{industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber}
 	}
 })
+
 industrialtest.api.registerCableFormerRecipe({
 	output="industrialtest:copper_cable 12",
 	recipe=industrialtest.elementKeys.copperIngot
 })
 
-registerCable("gold","Gold",0.15,industrialtest.api.hvPowerFlow,true)
+industrialtest.GoldCable=table.copy(industrialtest.Cable)
+industrialtest.internal.unpackTableInto(industrialtest.GoldCable,{
+	name="industrialtest:gold_cable",
+	description=S("Gold Cable"),
+	inventoryImage="industrialtest_gold_cable_inv.png",
+	tile="industrialtest_gold_cable.png",
+	size=0.15,
+	flow=industrialtest.api.hvPowerFlow,
+	insulated={
+		name="industrialtest:insulated_gold_cable",
+		description=S("Insulated Gold Cable"),
+		inventoryImage="industrialtest_insulated_gold_cable_inv.png",
+		tile="industrialtest_insulated_gold_cable.png"
+	}
+})
+
+industrialtest.GoldCable:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:gold_cable 6",
@@ -219,6 +305,7 @@ minetest.register_craft({
 		{industrialtest.elementKeys.goldIngot,industrialtest.elementKeys.goldIngot,industrialtest.elementKeys.goldIngot}
 	}
 })
+
 minetest.register_craft({
 	type="shapeless",
 	output="industrialtest:insulated_gold_cable",
@@ -227,6 +314,7 @@ minetest.register_craft({
 		industrialtest.elementKeys.rubber
 	}
 })
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:insulated_gold_cable 6",
@@ -236,12 +324,30 @@ minetest.register_craft({
 		{industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber}
 	}
 })
+
 industrialtest.api.registerCableFormerRecipe({
 	output="industrialtest:gold_cable 12",
 	recipe=industrialtest.elementKeys.goldIngot
 })
 
-registerCable("iron","Iron",0.15,industrialtest.api.evPowerFlow,true)
+industrialtest.IronCable=table.copy(industrialtest.Cable)
+industrialtest.internal.unpackTableInto(industrialtest.IronCable,{
+	name="industrialtest:iron_cable",
+	description=S("Iron Cable"),
+	inventoryImage="industrialtest_iron_cable_inv.png",
+	tile="industrialtest_iron_cable.png",
+	size=0.15,
+	flow=industrialtest.api.evPowerFlow,
+	insulated={
+		name="industrialtest:insulated_iron_cable",
+		description=S("Insulated Iron Cable"),
+		inventoryImage="industrialtest_insulated_iron_cable_inv.png",
+		tile="industrialtest_insulated_iron_cable.png"
+	}
+})
+
+industrialtest.IronCable:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:iron_cable 6",
@@ -249,6 +355,7 @@ minetest.register_craft({
 		{"industrialtest:refined_iron_ingot","industrialtest:refined_iron_ingot","industrialtest:refined_iron_ingot"}
 	}
 })
+
 minetest.register_craft({
 	type="shapeless",
 	output="industrialtest:insulated_iron_cable",
@@ -257,6 +364,7 @@ minetest.register_craft({
 		industrialtest.elementKeys.rubber
 	}
 })
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:insulated_iron_cable 6",
@@ -266,13 +374,27 @@ minetest.register_craft({
 		{industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber,industrialtest.elementKeys.rubber}
 	}
 })
+
 industrialtest.api.registerCableFormerRecipe({
 	output="industrialtest:iron_cable 12",
 	recipe="industrialtest:refined_iron_ingot",
 	time=3
 })
 
-registerCable("glass_fibre","Glass Fibre",0.15,industrialtest.api.ivPowerFlow,false)
+industrialtest.GlassFibreCable=table.copy(industrialtest.Cable)
+industrialtest.internal.unpackTableInto(industrialtest.GlassFibreCable,{
+	name="industrialtest:glass_fibre_cable",
+	description=S("Glass Fibre Cable"),
+	inventoryImage="industrialtest_glass_fibre_cable_inv.png",
+	transparent=true,
+	tile="industrialtest_glass_fibre_cable.png",
+	safe=true,
+	size=0.12,
+	flow=industrialtest.api.ivPowerFlow
+})
+
+industrialtest.GlassFibreCable:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:glass_fibre_cable 4",
@@ -283,3 +405,52 @@ minetest.register_craft({
 	}
 })
 -- TODO: Add glass fibre cable craft with silver ingot
+
+if industrialtest.config.electrocution then
+	local electrocutionDelta=0
+	minetest.register_globalstep(function(dtime)
+		electrocutionDelta=electrocutionDelta+dtime
+		if electrocutionDelta<industrialtest.config.updateDelay then
+			return
+		end
+		electrocutionDelta=0
+
+		local offsets={
+			vector.new(0,0,0),
+			vector.new(-0.7,0,0),
+			vector.new(-0.7,1,0),
+			vector.new(0,1,0),
+			vector.new(0.7,0,0),
+			vector.new(0.7,1,0),
+			vector.new(0,0,-0.7),
+			vector.new(0,1,-0.7),
+			vector.new(0,0,0.7),
+			vector.new(0,1,0.7)
+		}
+
+		local players=minetest.get_connected_players()
+		for _,player in ipairs(players) do
+			local pos=player:get_pos()
+			for _,offset in ipairs(offsets) do
+				local nodePos=vector.add(pos,offset)
+				local node=minetest.get_node(nodePos)
+				local def=minetest.registered_nodes[node.name]
+				if def and def.groups and def.groups._industrialtest_cable and not def.groups._industrialtest_insulatedCable then
+					local meta=minetest.get_meta(pos)
+					local networks=industrialtest.api.isAttachedToNetwork(meta)
+					if networks then
+						local current=0
+						for _,network in ipairs(networks) do
+							current=current+industrialtest.api.getFlowingCurrent(network)
+						end
+						if current>0 then
+							local removed=math.ceil(current/500)
+							player:set_hp(player:get_hp()-removed,"electrocution")
+							break
+						end
+					end
+				end
+			end
+		end
+	end)
+end

compat/logistica.lua

@@ -48,14 +48,17 @@ for _,name in ipairs(logistica.group_get_all_nodes_for_group("injectors")) do
 	minetest.override_item(name,override)
 end
 
-local function startNodeTimer(pos)
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+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=startNodeTimer,
-		_logistica_afterInjectorItemstackTake=startNodeTimer
+		_logistica_afterRequesterItemstackInsert=afterLogisticaAction,
+		_logistica_afterInjectorItemstackTake=afterLogisticaAction
 	}
 	minetest.override_item(name,override)
 end

compat/mesecons.lua

@@ -27,16 +27,15 @@ local override={
 				meta:set_int("maintainSpeed",1)
 
 				local def=minetest.registered_nodes[node.name]
-				def._industrialtest_updateFormspec(pos)
-
-				minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+				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_updateFormspec(pos)
+				def._industrialtest_self:updateFormspec(pos)
 			end
 		}
 	}
@@ -69,13 +68,13 @@ override={
 				meta:set_int("stateChanged",1)
 
 				local def=minetest.registered_nodes[node.name]
-				def._industrialtest_updateFormspec(pos)
+				def._industrialtest_self:updateFormspec(pos)
 
 				if isChamber then
-					def._industrialtest_synchronizeToChamber(originalPos)
+					def._industrialtest_self:synchronizeToChamber(originalPos)
 				end
 
-				minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+				def._industrialtest_self:triggerIfNeeded(pos)
 			end,
 			action_off=function(pos,node)
 				local isChamber=node.name=="industrialtest:nuclear_reactor_chamber"
@@ -107,10 +106,10 @@ override={
 				meta:set_int("stateChanged",1)
 
 				local def=minetest.registered_nodes[node.name]
-				def._industrialtest_updateFormspec(pos)
+				def._industrialtest_self:updateFormspec(pos)
 
 				if isChamber then
-					def._industrialtest_synchronizeToChamber(originalPos)
+					def._industrialtest_self:synchronizeToChamber(originalPos)
 				end
 			end
 		}

compat/pipeworks.lua

@@ -41,7 +41,10 @@ local function addPipeworksCompatibility(name,sides,inputInventory)
 					return nil
 				end
 				local result=inv:add_item(listname,stack)
-				minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+				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)
@@ -53,6 +56,16 @@ local function addPipeworksCompatibility(name,sides,inputInventory)
 				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,
@@ -157,7 +170,8 @@ local override={
 			local meta=minetest.get_meta(pos)
 			local inv=meta:get_inventory()
 			local result=inv:add_item(listname,stack)
-			minetest.registered_nodes["industrialtest:nuclear_reactor"].on_metadata_inventory_put(pos)
+			industrialtest.Reactor.synchronizeChambers(pos)
+			industrialtest.Reactor:triggerIfNeeded(pos)
 			return result
 		end,
 		can_insert=function(pos,node,stack,direction)
@@ -171,6 +185,14 @@ local override={
 			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,
@@ -207,10 +229,22 @@ override.tube.insert_object=function(pos,node,stack,direction)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local result=inv:add_item(listname,stack)
-	minetest.registered_nodes["industrialtest:nuclear_reactor_chamber"].on_metadata_inventory_put(pos)
+	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)
@@ -269,20 +303,21 @@ override={
 			if direction.y==1 then
 				listname="powerStorage"
 			elseif direction.y==-1 then
-				listname="fuel"
+				listname="src"
 			else
-				listname="target"
+				listname="dst"
 			end
 			local def=stack:get_definition()
 			if (listname=="powerStorage" and not industrialtest.api.hasPowerStorage(stack:get_meta())) or
-				(listname=="fuel" and (not def.groups or not def.groups._industrialtest_fuel)) or
-				(listname=="target" and (not def.groups or not def.groups._industrialtest_fueled)) then
+				(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)
+			local nodeDef=minetest.registered_nodes[node.name]
+			nodeDef._industrialtest_self:triggerIfNeeded(pos)
 			return result
 		end,
 		can_insert=function(pos,node,stack,direction)
@@ -290,21 +325,28 @@ override={
 			if direction.y==1 then
 				listname="powerStorage"
 			elseif direction.y==-1 then
-				listname="fuel"
+				listname="src"
 			else
-				listname="target"
+				listname="dst"
 			end
 			local def=stack:get_definition()
 			if (listname=="powerStorage" and not industrialtest.api.hasPowerStorage(stack:get_meta())) or
-				(listname=="fuel" and (not def.groups or not def.groups._industrialtest_fuel)) or
-				(listname=="target" and (not def.groups or not def.groups._industrialtest_fueled)) then
+				(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,
-		input_inventory="target",
+		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,

compatibility.lua

@@ -53,6 +53,21 @@ industrialtest.internal={}
 if industrialtest.mclAvailable then
 	industrialtest.stackMax=64
 
+	minetest.override_item("mcl_buckets:bucket_empty",{
+		groups={
+			_industrialtest_simpleFluidStorage=1
+		},
+		_industrialtest_getResultingFluidStorageItemByNode=function(fluidType)
+			local resultingItem=mcl_buckets.liquids[fluidType]
+			if resultingItem then
+				return {
+					name=resultingItem.bucketname
+				}
+			end
+		end,
+		_industrialtest_simpleFluidStorageCapacity=1000
+	})
+
 	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
@@ -90,6 +105,22 @@ if industrialtest.mclAvailable then
 elseif industrialtest.mtgAvailable then
 	industrialtest.stackMax=99
 
+	-- Override bucket to add function which will be used to query bucket with fluid
+	minetest.override_item("bucket:bucket_empty",{
+		groups={
+			_industrialtest_simpleFluidStorage=1
+		},
+		_industrialtest_getResultingFluidStorageItemByNode=function(fluidType)
+			local resultingItem=bucket.liquids[fluidType]
+			if resultingItem then
+				return {
+					name=resultingItem.itemname
+				}
+			end
+		end,
+		_industrialtest_simpleFluidStorageCapacity=1000
+	})
+
 	industrialtest.internal.explode=function(pos,radius)
 		tnt.boom(pos,{radius=radius})
 	end
@@ -450,6 +481,7 @@ if industrialtest.mclAvailable then
 	industrialtest.elementKeys.stick="mcl_core:stick"
 	industrialtest.elementKeys.flint="mcl_core:flint"
 	industrialtest.elementKeys.snowball="mcl_throwing:snowball"
+	industrialtest.elementKeys.snowBlock="mcl_core:snowblock"
 	industrialtest.elementKeys.string="mcl_mobitems:string"
 	industrialtest.elementKeys.junglePlanks="mcl_core:junglewood"
 	industrialtest.elementKeys.wood="mcl_core:tree"
@@ -505,6 +537,8 @@ if industrialtest.mclAvailable then
 	industrialtest.elementKeys.dryShrub="mcl_core:deadbush"
 	industrialtest.elementKeys.cactus="mcl_core:cactus"
 	industrialtest.elementKeys.gunpowder="mcl_mobitems:gunpowder"
+	industrialtest.elementKeys.chest="mcl_chests:chest_small"
+	industrialtest.elementKeys.paper="mcl_core:paper"
 	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")
@@ -690,6 +724,7 @@ elseif industrialtest.mtgAvailable then
 	industrialtest.elementKeys.stick="default:stick"
 	industrialtest.elementKeys.flint="default:flint"
 	industrialtest.elementKeys.snowball="default:snow"
+	industrialtest.elementKeys.snowBlock="default:snowblock"
 	industrialtest.elementKeys.blueDye="dye:blue"
 	industrialtest.elementKeys.yellowDust="dye:yellow"
 	industrialtest.elementKeys.bucket="bucket:bucket_empty"
@@ -738,6 +773,8 @@ elseif industrialtest.mtgAvailable then
 	industrialtest.elementKeys.dryShrub="default:dry_shrub"
 	industrialtest.elementKeys.cactus="default:cactus"
 	industrialtest.elementKeys.gunpowder="tnt:gunpowder"
+	industrialtest.elementKeys.chest="default:chest"
+	industrialtest.elementKeys.paper="default:paper"
 	industrialtest.elementKeys.groupSapling="group:sapling"
 	industrialtest.elementKeys.groupLeaves="group:leaves"
 	industrialtest.elementKeys.stickyResin="industrialtest:sticky_resin"

craftitems.lua

@@ -41,75 +41,6 @@ local colors={
 	coolant="#188676ff"
 }
 
--- Power storage items
-minetest.register_tool("industrialtest:re_battery",{
-	description=S("RE-Battery"),
-	inventory_image="industrialtest_re_battery.png",
-	_industrialtest_powerStorage=true,
-	_industrialtest_powerCapacity=7000,
-	_industrialtest_powerFlow=industrialtest.api.lvPowerFlow
-})
-minetest.register_craft({
-	type="shaped",
-	output="industrialtest:re_battery",
-	recipe={
-		{"","industrialtest:insulated_tin_cable",""},
-		{industrialtest.elementKeys.tinIngot,industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.tinIngot},
-		{industrialtest.elementKeys.tinIngot,industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.tinIngot}
-	}
-})
-
-minetest.register_tool("industrialtest:advanced_re_battery",{
-	description=S("Advanced RE-Battery"),
-	inventory_image="industrialtest_advanced_re_battery.png",
-	_industrialtest_powerStorage=true,
-	_industrialtest_powerCapacity=100000,
-	_industrialtest_powerFlow=industrialtest.api.mvPowerFlow
-})
-minetest.register_craft({
-	type="shaped",
-	output="industrialtest:advanced_re_battery",
-	recipe={
-		{"industrialtest:insulated_copper_cable",industrialtest.elementKeys.bronzeIngot,"industrialtest:insulated_copper_cable"},
-		{industrialtest.elementKeys.bronzeIngot,"industrialtest:sulfur_dust",industrialtest.elementKeys.bronzeIngot},
-		{industrialtest.elementKeys.bronzeIngot,"industrialtest:lead_dust",industrialtest.elementKeys.bronzeIngot}
-	}
-})
-
-minetest.register_tool("industrialtest:energy_crystal",{
-	description=S("Energy Crystal"),
-	inventory_image="industrialtest_energy_crystal.png",
-	_industrialtest_powerStorage=true,
-	_industrialtest_powerCapacity=100000,
-	_industrialtest_powerFlow=industrialtest.api.hvPowerFlow
-})
-minetest.register_craft({
-	type="shaped",
-	output="industrialtest:energy_crystal",
-	recipe={
-		{industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.powerCarrier},
-		{industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.diamond,industrialtest.elementKeys.powerCarrier},
-		{industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.powerCarrier}
-	}
-})
-
-minetest.register_tool("industrialtest:lapotron_crystal",{
-	description=S("Lapotron Crystal"),
-	inventory_image="industrialtest_lapotron_crystal.png",
-	_industrialtest_powerStorage=true,
-	_industrialtest_powerCapacity=1000000,
-	_industrialtest_powerFlow=industrialtest.api.evPowerFlow
-})
-minetest.register_craft({
-	type="shaped",
-	output="industrialtest:lapotron_crystal",
-	recipe={
-		{industrialtest.elementKeys.blueDye,"industrialtest:electronic_circuit",industrialtest.elementKeys.blueDye},
-		{industrialtest.elementKeys.blueDye,"industrialtest:energy_crystal",industrialtest.elementKeys.blueDye},
-		{industrialtest.elementKeys.blueDye,"industrialtest:electronic_circuit",industrialtest.elementKeys.blueDye}
-	}
-})
-
 -- Other resources
 minetest.register_craftitem("industrialtest:refined_iron_ingot",{
 	description=S("Refined Iron Ingot"),
@@ -572,6 +503,13 @@ industrialtest.api.registerPlate("carbon_plate",S("Carbon Plate"),{
 	}
 },"#272725ff",true)
 
+industrialtest.api.registerPlate("iron_plate",S("Iron Plate"),{
+	{
+		resource=industrialtest.elementKeys.ironIngot,
+		count=1
+	}
+},colors.iron,true)
+
 industrialtest.api.registerPlate("tin_plate",S("Tin Plate"),{
 	{
 		resource=industrialtest.elementKeys.tinIngot,
@@ -602,6 +540,9 @@ minetest.register_craftitem("industrialtest:empty_cell",{
 	description=S("Empty Cell"),
 	inventory_image="industrialtest_empty_cell.png",
 	liquids_pointable=true,
+	groups={
+		_industrialtest_simpleFluidStorage=1
+	},
 	on_place=function(itemstack,user,pointed)
 		if pointed.type~="node" or not user or not user:is_player() then
 			return nil
@@ -623,7 +564,9 @@ minetest.register_craftitem("industrialtest:empty_cell",{
 		end
 		minetest.remove_node(pointed.under)
 		return itemstack
-	end
+	end,
+	_industrialtest_getResultingFluidStorageItemByNode=industrialtest.api.getStorageCellByNode,
+	_industrialtest_simpleFluidStorageCapacity=1000
 })
 minetest.register_craft({
 	type="shaped",
@@ -871,38 +814,3 @@ industrialtest.api.registerCompressorRecipe({
 	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"}
-	}
-})
-
--- Item callbacks
-minetest.register_on_player_inventory_action(function(player,action,inventory,info)
-	if action=="put" then
-		if industrialtest.api.preparePowerStorageItem(info.stack) or industrialtest.api.prepareToolItem(info.stack) or industrialtest.api.prepareFluidStorageItem(info.stack) then
-			inventory:set_stack(info.listname,info.index,info.stack)
-		end
-	end
-end)
-minetest.register_on_craft(function(itemstack)
-	if industrialtest.api.preparePowerStorageItem(itemstack) or industrialtest.api.prepareToolItem(itemstack) then
-		return
-	end
-	industrialtest.api.prepareFluidStorageItem(itemstack)
-end)

crafts.lua

@@ -125,3 +125,12 @@ if industrialtest.mtgAvailable then
 		}
 	})
 end
+
+-- Pumped fluids
+if industrialtest.mtgAvailable then
+	industrialtest.api.registerPumpFluid("default:river_water_source","industrialtest_gui_river_water.png")
+	industrialtest.api.registerCompressedFluid("default:river_water_source",industrialtest.api.nodeFluidCapacity/2,5,"default:snow")
+end
+industrialtest.api.registerPumpFluid(industrialtest.elementKeys.waterSource,"industrialtest_gui_water.png")
+industrialtest.api.registerPumpFluid(industrialtest.elementKeys.lavaSource,"industrialtest_gui_lava.png")
+industrialtest.api.registerCompressedFluid(industrialtest.elementKeys.waterSource,industrialtest.api.nodeFluidCapacity/2,5,industrialtest.elementKeys.snowball)

init.lua

@@ -19,9 +19,12 @@ local modpath=minetest.get_modpath("industrialtest")
 -- table with global functions, variables etc
 industrialtest={}
 
--- Initial constants
-industrialtest.updateDelay=1 -- Note: Make this value smaller to make machines update more frequently (it may make server more laggy)
-industrialtest.developerMode=true -- Enables additional utils useful when developing mod
+-- Settings
+industrialtest.config={
+	updateDelay=tonumber(minetest.settings:get("industrialtest.updateDelay") or "1"),
+	electrocution=minetest.settings:get_bool("industrialtest.electrocution",true),
+	developerMode=minetest.settings:get_bool("industrialtest.developerMode",false)
+}
 
 -- Others
 industrialtest.random=PseudoRandom(os.time())
@@ -36,9 +39,7 @@ dofile(modpath.."/api/network.lua")
 dofile(modpath.."/api/power.lua")
 dofile(modpath.."/api/registration.lua")
 dofile(modpath.."/api/side.lua")
-dofile(modpath.."/api/tool.lua")
 
-dofile(modpath.."/machines/common.lua")
 dofile(modpath.."/machines/machine.lua")
 dofile(modpath.."/machines/activated_machine.lua")
 dofile(modpath.."/machines/electric_machine.lua")
@@ -55,9 +56,12 @@ 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/magnetizer.lua")
 dofile(modpath.."/machines/mass_fabricator.lua")
+dofile(modpath.."/machines/miner.lua")
 dofile(modpath.."/machines/nuclear_reactor.lua")
 dofile(modpath.."/machines/power_storage.lua")
+dofile(modpath.."/machines/pump.lua")
 dofile(modpath.."/machines/recycler.lua")
 dofile(modpath.."/machines/rotary_macerator.lua")
 dofile(modpath.."/machines/tool_workshop.lua")
@@ -66,14 +70,26 @@ 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/fluid_storage.lua")
 dofile(modpath.."/tools/jetpack.lua")
 dofile(modpath.."/tools/mining_laser.lua")
 dofile(modpath.."/tools/nano_suit.lua")
+dofile(modpath.."/tools/power_storage.lua")
+dofile(modpath.."/tools/scanner.lua")
 dofile(modpath.."/tools/solar_helmet.lua")
 dofile(modpath.."/tools/static_boots.lua")
 dofile(modpath.."/tools/treetap.lua")
@@ -82,8 +98,9 @@ dofile(modpath.."/tools/wrench.lua")
 
 dofile(modpath.."/upgrades.lua")
 dofile(modpath.."/craftitems.lua")
+dofile(modpath.."/guide.lua")
 dofile(modpath.."/nodes.lua")
-if industrialtest.developerMode then
+if industrialtest.config.developerMode then
 	dofile(modpath.."/utils.lua")
 end
 dofile(modpath.."/cables.lua")

machines/activated_machine.lua

@@ -66,7 +66,7 @@ function industrialtest.ActivatedMachine.activate(self,pos)
 		param2=minetest.get_node(pos).param2
 	})
 	self:afterActivation(pos)
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	minetest.get_node_timer(pos):start(industrialtest.config.updateDelay)
 end
 
 function industrialtest.ActivatedMachine.deactivate(self,pos)
@@ -75,7 +75,7 @@ function industrialtest.ActivatedMachine.deactivate(self,pos)
 		param2=minetest.get_node(pos).param2
 	})
 	self:afterDeactivation(pos)
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	minetest.get_node_timer(pos):start(industrialtest.config.updateDelay)
 end
 
 function industrialtest.ActivatedMachine.shouldActivate(self,pos)

machines/canning_machine.lua

@@ -99,7 +99,7 @@ function industrialtest.CanningMachine.getFormspec(self,pos)
 	return parentFormspec..table.concat(formspec,"")
 end
 
-function industrialtest.CanningMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,count)
+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)
@@ -112,10 +112,13 @@ function industrialtest.CanningMachine.allowMetadataInventoryMove(self,pos,fromL
 		local def=itemstack:get_definition()
 		return (def.groups and def.groups._industrialtest_fueled) and count or 0
 	end
-	return math.min(count,industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,count))
+	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)
+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
@@ -124,19 +127,22 @@ function industrialtest.CanningMachine.allowMetadataInventoryPut(self,pos,listna
 		local def=stack:get_definition()
 		return (def.groups and def.groups._industrialtest_fueled) and stack:get_count() or 0
 	end
-	return math.min(stack:get_count(),industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack))
+	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)
+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)
+		self:updateFormspec(pos)
 	end
-	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryTake(self,pos,listname,index,stack)
+	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryTake(self,pos,listname,index,stack,player)
 end
 
 function industrialtest.CanningMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
@@ -147,12 +153,12 @@ function industrialtest.CanningMachine.onMetadataInventoryMove(self,pos,fromList
 	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))
+		self:updateFormspec(pos)
 	end
 end
 
-function industrialtest.CanningMachine.onMetadataInventoryPut(self,pos)
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+function industrialtest.CanningMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
+	self:triggerIfNeeded(pos)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
 end
 
@@ -182,7 +188,7 @@ function industrialtest.CanningMachine.shouldDeactivate(self,pos)
 	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
+		targetMeta:get_int("industrialtest.fluidCapacity")-targetMeta:get_int("industrialtest.fluidAmount")<(fuelDef._industrialtest_fuelAmount or 0) or
 		(fuelDef._industrialtest_emptyVariant and not leftoverSlot:item_fits(ItemStack(fuelDef._industrialtest_emptyVariant)))
 end
 

machines/chargepad.lua

@@ -291,7 +291,7 @@ industrialtest.MFSUChargepad:register()
 minetest.register_abm({
 	label="Chargepad updating",
 	nodenames=industrialtest.internal.chargepads,
-	interval=industrialtest.updateDelay,
+	interval=industrialtest.config.updateDelay,
 	chance=1,
 	action=function(pos,node)
 		local def=minetest.registered_nodes[node.name]

machines/common.lua

@@ -1,160 +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={}
-
-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.chargeFromPowerStorageItem=function(meta,inv)
-	local shouldRerunTimer=false
-	local shouldUpdateFormspec=false
-	local powerStorageSlot=inv:get_stack("powerStorage",1)
-	if not powerStorageSlot:is_empty() then
-		local stackMeta=powerStorageSlot:get_meta()
-		if industrialtest.api.transferPower(stackMeta,meta,stackMeta:get_int("industrialtest.powerFlow"))>0 then
-			shouldUpdateFormspec=true
-			shouldRerunTimer=stackMeta:get_int("industrialtest.powerAmount")>0 and not industrialtest.api.isFullyCharged(meta)
-			industrialtest.api.updateItemPowerText(powerStorageSlot)
-			inv:set_stack("powerStorage",1,powerStorageSlot)
-		end
-	end
-	return shouldRerunTimer,shouldUpdateFormspec
-end
-
-function industrialtest.internal.registerMachine(config)
-	local definition={
-		description=config.displayName,
-		on_construct=function(pos)
-			machine.onConstruct(pos,config)
-		end,
-		on_destruct=function(pos)
-			machine.onDestruct(pos,config)
-		end,
-		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,
-		allow_metadata_inventory_take=function(pos,listname,index,stack,player)
-			return machine.allowMetadataInventoryTake(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,
-		_industrialtest_getFormspec=function(pos)
-			if config.withoutFormspec then
-				return ""
-			end
-			return machine.getFormspec(pos,config)
-		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
-	industrialtest.api.addTag("industrialtest:"..config.name,"usesTimer")
-end

machines/compressor.lua

@@ -62,8 +62,38 @@ function industrialtest.Compressor.getCraftResult(self,itemstack)
 	}
 end
 
+function industrialtest.Compressor.canPushFluid(self,pos,fluidType,fluidAmount)
+	local meta=minetest.get_meta(pos)
+	local compressedFluid=industrialtest.api.getCompressedFluid(fluidType)
+	if not self.isRecipeOverride(meta) and compressedFluid and fluidAmount>=compressedFluid.requiredAmount then
+		local inv=meta:get_inventory()
+		local resultingStack=ItemStack(compressedFluid.result)
+		if inv:room_for_item("dst",resultingStack) then
+			return true
+		end
+	end
+	return false
+end
+
+-- Called by Pump when Compressor is next to it while it tries to push fluid
+function industrialtest.Compressor.onPumpFluidPush(self,pos,pumpPos,fluidType,fluidAmount)
+	local compressedFluid=industrialtest.api.getCompressedFluid(fluidType)
+	if compressedFluid then
+		local meta=minetest.get_meta(pos)
+		-- If recipe can be overriden keep information about this in meta so it's picked up by superclass
+		meta:set_string("recipeOverride",compressedFluid.result)
+		meta:set_int("recipeOverrideMaxTime",compressedFluid.time)
+		fluidAmount=fluidAmount-compressedFluid.requiredAmount
+		self:triggerIfNeeded(pos)
+	end
+	return fluidAmount
+end
+
 industrialtest.Compressor:register()
 
+industrialtest.api.registerPumpTarget("industrialtest:compressor","o")
+industrialtest.api.registerPumpTarget("industrialtest:compressor_active","o")
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:compressor",

machines/electric_machine.lua

@@ -29,10 +29,10 @@ function industrialtest.ElectricMachine.onConstruct(self,pos)
 				industrialtest.api.createNetworkMapForNode(conn)
 				local def=minetest.get_node(conn)
 				if def and def._industrialtest_self then
-					def._industrialtest_self:requestPower(conn)
+					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)
+					minetest.get_node_timer(conn):start(industrialtest.config.updateDelay)
 				end
 			else
 				local def=minetest.registered_nodes[minetest.get_node(conn).name]
@@ -41,12 +41,12 @@ function industrialtest.ElectricMachine.onConstruct(self,pos)
 					if networks then
 						for _,network in ipairs(networks) do
 							industrialtest.api.createNetworkMapForNode(network)
-							local def=minetest.get_node(network)
+							local def=minetest.registered_nodes[minetest.get_node(network).name]
 							if def and def._industrialtest_self then
-								def._industrialtest_self:requestPower(network)
+								def._industrialtest_self:flowPower(network)
 							else
 								-- Support for bare definitions that don't use industrialtest pseudo-OOP
-								minetest.get_node_timer(conn):start(industrialtest.updateDelay)
+								minetest.get_node_timer(network):start(industrialtest.config.updateDelay)
 							end
 						end
 					end
@@ -98,7 +98,7 @@ function industrialtest.ElectricMachine.allowMetadataInventoryMove(self,pos,from
 	local found=false
 	if self.powerLists then
 		for _,value in ipairs(self.powerLists) do
-			if value==toList then
+			if value.list==toList then
 				found=true
 				break
 			end
@@ -115,7 +115,7 @@ function industrialtest.ElectricMachine.allowMetadataInventoryPut(self,pos,listn
 	local found=false
 	if self.powerLists then
 		for _,value in ipairs(self.powerLists) do
-			if value==listname then
+			if value.list==listname then
 				found=true
 				break
 			end
@@ -129,20 +129,30 @@ function industrialtest.ElectricMachine.allowMetadataInventoryPut(self,pos,listn
 end
 
 function industrialtest.ElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	if toList=="charged" then
+	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 listname=="charged" then
+	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.requestPower(self,pos)
+function industrialtest.ElectricMachine.flowPower(self,pos)
 	if not self.hasPowerOutput then
 		return
 	end
@@ -157,23 +167,28 @@ function industrialtest.ElectricMachine.requestPower(self,pos)
 	self:triggerIfNeeded(pos)
 end
 
-function industrialtest.ElectricMachine.powerExchange(self,pos)
+function industrialtest.ElectricMachine.requestPower(self,pos)
 	local meta=minetest.get_meta(pos)
-	local shouldRerunTimer=false
-
-	if self.hasPowerInput and not industrialtest.api.isFullyCharged(meta) then
 	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:requestPower(network)
+				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)
+				minetest.get_node_timer(network):start(industrialtest.config.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
 

machines/fluid_generator.lua

@@ -94,6 +94,7 @@ local function takeFuelFromItem(self,pos)
 			inv:set_stack("src",1,fluidSlot)
 			meta:set_string("fluid",fuel.name)
 			meta:set_float("fluidAmount",fluidAmount+1000)
+			self:updateFormspec(pos)
 			return true
 		end
 	end
@@ -167,6 +168,13 @@ function industrialtest.GeothermalGenerator.onConstruct(self,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
@@ -191,16 +199,22 @@ 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 and not industrialtest.api.isFullyCharged(meta)
+	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 or industrialtest.api.isFullyCharged(meta)
+	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)
@@ -270,9 +284,12 @@ 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 and not industrialtest.api.isFullyCharged(meta)
+	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)
@@ -350,7 +367,7 @@ minetest.register_abm({
 	label="Water Mill generating",
 	nodenames={"industrialtest:water_mill"},
 	neighbors=neighbors,
-	interval=industrialtest.updateDelay,
+	interval=industrialtest.config.updateDelay,
 	chance=1,
 	action=function(pos)
 		industrialtest.WaterMill:action(pos)

machines/generator.lua

@@ -85,7 +85,7 @@ function industrialtest.Generator.getFormspec(self,pos)
 end
 
 function industrialtest.Generator.onMetadataInventoryPut(self,pos,listname,index,stack)
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	self:triggerIfNeeded(pos)
 	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
 end
 

machines/iron_furnace.lua

@@ -131,7 +131,7 @@ function industrialtest.IronFurnace.allowMetadataInventoryTake(self,pos,listname
 			self:updateFormspec(pos)
 		end
 	elseif listname=="dst" and dstSlot:get_free_space()==0 then
-		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		self:triggerIfNeeded(pos)
 	end
 	return industrialtest.ActivatedMachine.allowMetadataInventoryTake(self,pos,listname,index,stack)
 end
@@ -148,13 +148,13 @@ function industrialtest.IronFurnace.onMetadataInventoryMove(self,pos,fromList,fr
 			self:updateFormspec(pos)
 		end
 	elseif fromList=="dst" and dstSlot:get_free_space()==0 then
-		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		self:triggerIfNeeded(pos)
 	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)
+	self:triggerIfNeeded(pos)
 	industrialtest.ActivatedMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
 end
 

machines/machine.lua

@@ -18,8 +18,10 @@ 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))
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	end
+	self:trigger(pos)
 end
 
 function industrialtest.Machine.onDestruct(self)
@@ -30,6 +32,15 @@ function industrialtest.Machine.afterPlaceNode(self,pos,placer,itemstack,pointed
 	-- dummy function
 end
 
+function industrialtest.Machine.afterDigNode(self,pos,oldnode,oldmetadata,digger)
+	-- dummy function
+end
+
+function industrialtest.Machine.onDig(self,pos,node,digger)
+	-- dummy function
+	return minetest.node_dig(pos,node,digger)
+end
+
 function industrialtest.Machine.getFormspec(self,pos)
 	local formspec
 	if industrialtest.mtgAvailable then
@@ -71,8 +82,7 @@ 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)
+		timer:start(industrialtest.config.updateDelay)
 	end
 end
 
@@ -127,27 +137,37 @@ function industrialtest.Machine.onMetadataInventoryMove(self,pos,fromList,fromIn
 	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)
+		local itemstack=inv:get_stack(fromList,fromIndex)
+		local def=itemstack:get_definition()
+		if def and def._industrialtest_self and def._industrialtest_self.apply then
+			def._industrialtest_self:apply(pos)
+		end
 	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)
+		local itemstack=inv:get_stack(fromList,fromIndex)
+		local def=itemstack:get_definition()
+		if def and def._industrialtest_self and def._industrialtest_self.remove then
+			def._industrialtest_self:remove(pos)
+		end
 	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)
+		local def=stack:get_definition()
+		if def and def._industrialtest_self and def._industrialtest_self.apply then
+			def._industrialtest_self:apply(pos)
+		end
 	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)
+		local def=stack:get_definition()
+		if def and def._industrialtest_self and def._industrialtest_self.remove then
+			def._industrialtest_self:remove(pos)
+		end
 	end
 end
 
@@ -155,6 +175,22 @@ 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,
@@ -168,6 +204,12 @@ function industrialtest.Machine.createDefinitionTable(self)
 		after_place_node=function(pos,placer,itemstack,pointed)
 			self:afterPlaceNode(pos,placer,itemstack,pointed)
 		end,
+		after_dig_node=function(pos,oldnode,oldmetadata,digger)
+			self:afterDigNode(pos,oldnode,oldmetadata,digger)
+		end,
+		on_dig=function(pos,node,digger)
+			return self:onDig(pos,node,digger)
+		end,
 		on_timer=function(pos,elapsed)
 			return self:onTimer(pos,elapsed)
 		end,
@@ -214,7 +256,7 @@ function industrialtest.Machine.createDefinitionTable(self)
 		end
 	elseif industrialtest.mclAvailable then
 		def.after_dig_node=function(pos,oldnode,oldmeta)
-			industrialtest.internal.mclAfterDigNode(pos,oldmeta,self.storageLists)
+			mclAfterDigNode(pos,oldmeta,self.storageLists)
 		end
 		if self.sounds=="metal" then
 			def.sounds=mcl_sounds.node_sound_metal_defaults()
@@ -242,7 +284,7 @@ function industrialtest.Machine.createDefinitionTable(self)
 			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)
+			self:triggerIfNeeded(pos)
 		end
 	end
 
@@ -272,8 +314,8 @@ function industrialtest.Machine.register(self)
 	industrialtest.api.addTag(self.name,"usesTimer")
 end
 
-function industrialtest.Machine.allowMoveToUpgradeSlot(pos,toIndex,stack)
-	local def=minetest.registered_items[stack:get_name()]
+function industrialtest.Machine.allowMoveToUpgradeSlot(pos,toIndex,itemstack)
+	local def=itemstack:get_definition()
 	if not def or not def.groups or not def.groups._industrialtest_machineUpgrade then
 		return 0
 	end
@@ -283,5 +325,5 @@ function industrialtest.Machine.allowMoveToUpgradeSlot(pos,toIndex,stack)
 	if not targetSlot:is_empty() then
 		return 0
 	end
-	return stack:get_count()
+	return itemstack:get_count()
 end

machines/magnetizer.lua

@@ -0,0 +1,272 @@
+-- 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/>.
+
+local S=minetest.get_translator("industrialtest")
+
+local function findFenceRailEnd(initialPosition,direction)
+	local y=initialPosition.y
+	local railNode=minetest.get_node(vector.new(initialPosition.x,y,initialPosition.z))
+	while minetest.get_item_group(railNode.name,"_industrialtest_metalFence")>0 and math.abs(initialPosition.y-y)<=19 do
+		y=y+direction
+		railNode=minetest.get_node(vector.new(initialPosition.x,y,initialPosition.z))
+	end
+	return y-direction
+end
+
+local function hasMetalBoots(player)
+	local inv
+	if industrialtest.mtgAvailable then
+		_,inv=armor:get_valid_player(player,"")
+	elseif industrialtest.mclAvailable then
+		inv=player:get_inventory()
+	end
+
+	if inv then
+		local armorList=inv:get_list("armor")
+		assert(armorList)
+		local requiredGroups={
+			"armor_iron",
+			"armor_gold",
+			"armor_bronze",
+			"_industrialtest_electricArmor"
+		}
+		-- 3D armor boots have to be hardcoded here because they don't provide any group depending on material
+		local requiredNames={
+			"3d_armor:boots_steel",
+			"3d_armor:boots_gold",
+			"3d_armor:boots_bronze"
+		}
+		for _,itemstack in ipairs(armorList) do
+			local def=itemstack:get_definition()
+			if def and def.groups and def.groups.armor_feet then
+				for _,group in ipairs(requiredGroups) do
+					if def.groups[group] then
+						-- Matching group succeeded
+						return true
+					end
+				end
+			end
+			for _,itemname in ipairs(requiredNames) do
+				if itemname==itemstack:get_name() then
+					-- Matching itemname succeeded
+					return true
+				end
+			end
+		end
+	end
+
+	return false
+end
+
+industrialtest.Magnetizer=table.copy(industrialtest.ElectricMachine)
+industrialtest.internal.unpackTableInto(industrialtest.Magnetizer,{
+	name="industrialtest:magnetizer",
+	description=S("Magnetizer"),
+	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_magnetizer_front.png"
+	},
+	sounds="metal",
+	facedir=true,
+	storageLists={
+		"powerStorage"
+	},
+	powerLists={
+		{
+			list="powerStorage",
+			direction="i"
+		}
+	},
+	capacity=industrialtest.api.lvPowerFlow*2,
+	flow=industrialtest.api.lvPowerFlow,
+	ioConfig="iiiiii",
+	requiresWrench=true,
+	hasPowerInput=true,
+	_capacityPerFence=15,
+	_opPower=4
+})
+
+function industrialtest.Magnetizer.onConstruct(self,pos)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	inv:set_size("powerStorage",1)
+	self:determineFenceRail(pos)
+	self:determinePowerCapacity(pos)
+	industrialtest.ElectricMachine.onConstruct(self,pos)
+end
+
+function industrialtest.Magnetizer.onDestruct(self,pos)
+	self.detachFenceRail(pos)
+	industrialtest.ElectricMachine.onDestruct(self,pos)
+end
+
+function industrialtest.Magnetizer.onDig(self,pos,node,digger)
+	self.detachFenceRail(pos)
+	return industrialtest.ElectricMachine.onDig(self,pos,node,digger)
+end
+
+function industrialtest.Magnetizer.getFormspec(self,pos)
+	local parentFormspec=industrialtest.ElectricMachine.getFormspec(self,pos)
+	local meta=minetest.get_meta(pos)
+	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
+	local formspec={
+		(powerPercent>0 and "image[4.7,2.7;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
+		 or "image[4.7,2.7;1,1;industrialtest_gui_electricity_bg.png]"),
+		"list[context;powerStorage;4.7,3.7;1,1]",
+		"listring[context;powerStorage]"
+	}
+	return parentFormspec..table.concat(formspec,"")
+end
+
+function industrialtest.Magnetizer.determinePowerCapacity(self,pos)
+	local meta=minetest.get_meta(pos)
+	if meta:contains("lowY") and meta:contains("highY") then
+		local lowY=meta:get_int("lowY")
+		local highY=meta:get_int("highY")
+		local capacity=self.capacity+(highY-lowY)*self._capacityPerFence
+		meta:set_int("industrialtest.powerCapacity",capacity)
+	end
+end
+
+-- Checks all sides on the same Y level if there is rail made from metal fences attached
+function industrialtest.Magnetizer.determineFenceRail(self,pos)
+	local neighbourPositions={
+		vector.offset(pos,-1,0,0),
+		vector.offset(pos,1,0,0),
+		vector.offset(pos,0,0,-1),
+		vector.offset(pos,0,0,1)
+	}
+	local railPosition
+	for _,neighbourPosition in ipairs(neighbourPositions) do
+		local neighbourNode=minetest.get_node(neighbourPosition)
+		if minetest.get_item_group(neighbourNode.name,"_industrialtest_metalFence")>0 then
+			railPosition=neighbourPosition
+			break
+		end
+	end
+	if not railPosition then
+		return
+	end
+
+	local direction=vector.subtract(railPosition,pos)
+	minetest.swap_node(pos,{
+		name=self.name,
+		-- Some cryptic code that converts direction vector to param2
+		param2=direction.z+1*math.abs(direction.z)+direction.x+2*math.abs(direction.x)
+	})
+
+	-- Find low and high points of fence rail
+	local lowY=findFenceRailEnd(railPosition,-1)
+	local highY=findFenceRailEnd(railPosition,1)
+
+	-- Keep magnetizer position in fence metadata so new fences can be attached easily
+	for y=lowY,highY,1 do
+		local meta=minetest.get_meta(vector.new(railPosition.x,y,railPosition.z))
+		meta:set_string("magnetizerPosition",minetest.serialize(pos))
+	end
+
+	local meta=minetest.get_meta(pos)
+	meta:set_string("railPosition",minetest.serialize(railPosition))
+	meta:set_int("lowY",lowY)
+	meta:set_int("highY",highY)
+end
+
+function industrialtest.Magnetizer.detachFenceRail(pos)
+	local meta=minetest.get_meta(pos)
+	if not meta:contains("railPosition") or not meta:contains("lowY") or not meta:contains("highY") then
+		return
+	end
+
+	local railPosition=minetest.deserialize(meta:get_string("railPosition"))
+	local lowY=meta:get_int("lowY")
+	local highY=meta:get_int("highY")
+	for y=lowY,highY,1 do
+		local fenceMeta=minetest.get_meta(vector.new(railPosition.x,y,railPosition.z))
+		fenceMeta:set_string("magnetizerPosition","")
+	end
+	meta:set_string("railPosition","")
+end
+
+industrialtest.Magnetizer:register()
+
+minetest.register_craft({
+	type="shaped",
+	output="industrialtest:magnetizer",
+	recipe={
+		{industrialtest.elementKeys.powerCarrier,"industrialtest:iron_fence",industrialtest.elementKeys.powerCarrier},
+		{industrialtest.elementKeys.powerCarrier,"industrialtest:machine_block",industrialtest.elementKeys.powerCarrier},
+		{industrialtest.elementKeys.powerCarrier,"industrialtest:iron_fence",industrialtest.elementKeys.powerCarrier}
+	}
+})
+
+-- Players to which Y velocity should be added
+local validatedPlayers={}
+-- Time since last check to which players the effect should be applied
+local validationDelta=0.2
+minetest.register_globalstep(function(dtime)
+	validationDelta=validationDelta+dtime
+	if validationDelta>=0.2 then
+		validatedPlayers={}
+		local players=minetest.get_connected_players()
+		for _,player in ipairs(players) do
+			local control=player:get_player_control()
+			if (control.jump or control.sneak) and hasMetalBoots(player) then
+				local props=player:get_properties()
+				local pos=player:get_pos()
+				local offsets={
+					vector.new(props.collisionbox[1],0,0),
+					vector.new(props.collisionbox[4],0,0),
+					vector.new(0,0,props.collisionbox[3]),
+					vector.new(0,0,props.collisionbox[6])
+				}
+				for _,offset in ipairs(offsets) do
+					local targetPos=vector.add(pos,offset)
+					local targetNode=minetest.get_node(targetPos)
+					if minetest.get_item_group(targetNode.name,"_industrialtest_metalFence")>0 then
+						local fenceMeta=minetest.get_meta(targetPos)
+						if fenceMeta:contains("magnetizerPosition") then
+							table.insert(validatedPlayers,{
+								playerName=player:get_player_name(),
+								magnetizerPosition=minetest.deserialize(fenceMeta:get_string("magnetizerPosition")),
+								multiplier=(control.sneak and 0.55 or 1)
+							})
+							break
+						end
+					end
+				end
+			end
+		end
+	end
+
+	for _,validatedPlayer in ipairs(validatedPlayers) do
+		local player=minetest.get_player_by_name(validatedPlayer.playerName)
+		if player then
+			local magnetizerMeta=minetest.get_meta(validatedPlayer.magnetizerPosition)
+			local physicsOverride=player:get_physics_override()
+			local requiredPower=industrialtest.Magnetizer._opPower*physicsOverride.gravity
+			if magnetizerMeta:get_int("industrialtest.powerAmount")>=requiredPower then
+				industrialtest.api.addPower(magnetizerMeta,-requiredPower)
+				industrialtest.Magnetizer:requestPower(validatedPlayer.magnetizerPosition)
+				industrialtest.Magnetizer:updateFormspec(validatedPlayer.magnetizerPosition)
+				industrialtest.internal.addYVelocityClamped(player,30*dtime*physicsOverride.gravity*validatedPlayer.multiplier,5*physicsOverride.gravity)
+			end
+		end
+	end
+end)

machines/miner.lua

@@ -0,0 +1,417 @@
+-- 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/>.
+
+local S=minetest.get_translator("industrialtest")
+
+local function destructMiningPipe(pos,player)
+	local count=0
+	local originalPos=table.copy(pos)
+	local node=minetest.get_node(pos)
+	while node.name=="industrialtest:mining_pipe" do
+		count=count+1
+		pos.y=pos.y-1
+		node=minetest.get_node(pos)
+		if node.name=="ignore" then
+			minetest.load_area(pos)
+			node=minetest.get_node(pos)
+		end
+	end
+	local endPos=table.copy(pos)
+
+	local manip=minetest.get_voxel_manip()
+	local minp,maxp=manip:read_from_map(pos,originalPos)
+	local data=manip:get_data()
+	local area=VoxelArea(minp,maxp)
+	pos=table.copy(originalPos)
+	while pos.y>endPos.y do
+		data[area:index(pos.x,pos.y,pos.z)]=minetest.CONTENT_AIR
+		pos.y=pos.y-1
+	end
+	manip:set_data(data)
+	manip:write_to_map()
+
+	if player then
+		local itemstack=ItemStack("industrialtest:mining_pipe "..tostring(count))
+		if industrialtest.mtgAvailable then
+			local inv=player:get_inventory()
+			local leftover=inv:add_item("main",itemstack)
+			if not leftover:is_empty() then
+				minetest.add_item(player:get_pos(),leftover)
+			end
+		elseif industrialtest.mclAvailable then
+			minetest.add_item(originalPos,itemstack)
+		end
+	end
+end
+
+local function miningPipeUpdateMiner(pos)
+	local meta=minetest.get_meta(pos)
+	if meta:contains("miner") then
+		local minerPos=minetest.deserialize(meta:get_string("miner"))
+		local minerMeta=minetest.get_meta(minerPos)
+		minerMeta:set_int("level",pos.y)
+	end
+end
+
+local definition={
+	description=S("Mining Pipe"),
+	tiles={"industrialtest_mining_pipe.png"},
+	paramtype="light",
+	sunlight_propagates=true,
+	drawtype="nodebox",
+	node_box={
+		type="fixed",
+		fixed={
+			-0.25,
+			-0.5,
+			-0.25,
+			0.25,
+			0.5,
+			0.25
+		}
+	},
+	on_destruct=function(pos)
+		miningPipeUpdateMiner(pos)
+		destructMiningPipe(pos,nil)
+	end,
+	on_dig=function(pos,node,digger)
+		miningPipeUpdateMiner(pos)
+		destructMiningPipe(pos,digger)
+	end
+}
+if industrialtest.mtgAvailable then
+	definition.groups={
+		cracky=3,
+		oddly_breakable_by_hand=1
+	}
+	definition.sounds=default.node_sound_metal_defaults()
+elseif industrialtest.mclAvailable then
+	definition.groups={
+		pickaxey=1,
+		handy=1
+	}
+	definition.sounds=mcl_sounds.node_sound_metal_defaults()
+	definition._mcl_blast_resistance=1
+	definition._mcl_hardness=1
+end
+minetest.register_node("industrialtest:mining_pipe",definition)
+
+minetest.register_craft({
+	type="shaped",
+	output="industrialtest:mining_pipe 8",
+	recipe={
+		{"industrialtest:refined_iron_ingot","","industrialtest:refined_iron_ingot"},
+		{"industrialtest:refined_iron_ingot","","industrialtest:refined_iron_ingot"},
+		{"industrialtest:refined_iron_ingot",industrialtest.elementKeys.treetap,"industrialtest:refined_iron_ingot"}
+	}
+})
+
+industrialtest.Miner=table.copy(industrialtest.ElectricMachine)
+industrialtest.internal.unpackTableInto(industrialtest.Miner,{
+	name="industrialtest:miner",
+	description=S("Miner"),
+	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_miner_front.png"
+	},
+	sounds="metal",
+	storageLists={
+		"drill",
+		"src",
+		"scanner",
+		"dst",
+		"powerStorage",
+		"upgrades"
+	},
+	powerLists={
+		{
+			list="powerStorage",
+			direction="i"
+		}
+	},
+	requiresWrench=true,
+	facedir=true,
+	flow=industrialtest.api.lvPowerFlow,
+	capacity=5000,
+	ioConfig="iiiiii",
+	hasPowerInput=true,
+	_opPower=1000,
+	_scannerOpPower=10
+})
+
+function industrialtest.Miner.onConstruct(self,pos)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	inv:set_size("drill",1)
+	inv:set_size("src",1)
+	inv:set_size("scanner",1)
+	inv:set_size("dst",15)
+	inv:set_size("powerStorage",1)
+	inv:set_size("upgrades",1)
+	meta:set_int("level",pos.y-1)
+	-- Keep last fluid node here so pump has more time to access it
+	meta:set_string("lastFluidNode","")
+	industrialtest.ElectricMachine.onConstruct(self,pos)
+end
+
+function industrialtest.Miner.onDestruct(self,pos)
+	destructMiningPipe(vector.new(pos.x,pos.y-1,pos.z),nil)
+	industrialtest.ElectricMachine.onDestruct(self,pos)
+end
+
+function industrialtest.Miner.onDig(self,pos,node,digger)
+	destructMiningPipe(vector.new(pos.x,pos.y-1,pos.z),digger)
+	return industrialtest.ElectricMachine.onDig(self,pos,node,digger)
+end
+
+function industrialtest.Miner.getFormspec(self,pos)
+	local parentFormspec=industrialtest.ElectricMachine.getFormspec(self,pos)
+	local meta=minetest.get_meta(pos)
+	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
+	local formspec={
+		"label[0.7,1.15;"..S("Drill").."]",
+		"list[context;drill;0.7,1.5;1,1]",
+		industrialtest.internal.getItemSlotBg(0.7,1.5,1,1),
+		"label[0.7,2.75;"..S("Pipe").."]",
+		"list[context;src;0.7,3.1;1,1]",
+		industrialtest.internal.getItemSlotBg(0.7,3.1,1,1),
+		"label[0.7,4.35;"..S("Scanner").."]",
+		"list[context;scanner;0.7,4.7;1,1]",
+		industrialtest.internal.getItemSlotBg(0.7,4.7,1,1),
+		"list[context;dst;2.28,1.9;5,3]",
+		industrialtest.internal.getItemSlotBg(2.28,1.9,5,3),
+		"list[context;upgrades;9.1,1.2;1,1]",
+		industrialtest.internal.getItemSlotBg(9.1,1.2,1,1),
+		(powerPercent>0 and "image[9.1,2.29;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
+		 or "image[9.1,2.29;1,1;industrialtest_gui_electricity_bg.png]"),
+		"list[context;powerStorage;9.1,3.5;1,1]",
+		industrialtest.internal.getItemSlotBg(9.1,3.5,1,1),
+		"listring[context;src]",
+		"listring[context;dst]"
+	}
+	return parentFormspec..table.concat(formspec,"")
+end
+
+function industrialtest.Miner.canUpdate(self,pos)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local drillSlot=inv:get_stack("drill",1)
+	local srcSlot=inv:get_stack("src",1)
+	local level=meta:get_int("level")
+	local requiredPower=self:getRequiredPower(pos)
+	return meta:get_int("industrialtest.powerAmount")>=requiredPower and not drillSlot:is_empty() and not srcSlot:is_empty() and
+		self:canContinue(pos,level)
+end
+
+function industrialtest.Miner.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local itemstack=inv:get_stack(fromList,fromIndex)
+	if toList=="drill" then
+		return self.allowDrillPut(itemstack) and count or 0
+	end
+	if toList=="src" then
+		return itemstack:get_name()=="industrialtest:mining_pipe" and count or 0
+	end
+	if toList=="scanner" then
+		return self.allowScannerPut(itemstack) and 1 or 0
+	end
+	if toList=="dst" then
+		return 0
+	end
+	return industrialtest.ElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+end
+
+function industrialtest.Miner.allowMetadataInventoryPut(self,pos,listname,index,itemstack,player)
+	if listname=="drill" then
+		return self.allowDrillPut(itemstack) and itemstack:get_count() or 0
+	end
+	if listname=="src" then
+		return itemstack:get_name()=="industrialtest:mining_pipe" and itemstack:get_count() or 0
+	end
+	if listname=="scanner" then
+		return self.allowScannerPut(itemstack) and 1 or 0
+	end
+	if listname=="dst" then
+		return 0
+	end
+	return industrialtest.ElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,itemstack,player)
+end
+
+function industrialtest.Miner.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+	self:onInventoryPut(pos,toList)
+	industrialtest.ElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+end
+
+function industrialtest.Miner.onMetadataInventoryPut(self,pos,listname,index,stack)
+	self:onInventoryPut(pos,listname)
+	industrialtest.ElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
+end
+
+function industrialtest.Miner.onMetadataInventoryTake(self,pos,listname,index,stack)
+	if listname=="dst" then
+		self:triggerIfNeeded(pos)
+	end
+end
+
+function industrialtest.Miner.update(self,pos,elapsed,meta,inv)
+	if not self:canUpdate(pos) then
+		return false,false
+	end
+
+	local level=meta:get_int("level")
+	if not self:canContinue(pos,level) then
+		return false,false
+	end
+
+	local srcSlot=inv:get_stack("src",1)
+	srcSlot:take_item(1)
+	inv:set_stack("src",1,srcSlot)
+	local targetPos=vector.new(pos.x,level,pos.z)
+
+	-- Check if target node is fluid so pump, if attached, can get it
+	local targetNode=minetest.get_node(targetPos)
+	local targetFluid=industrialtest.api.getPumpFluid(targetNode.name)
+	if targetFluid then
+		meta:set_string("lastFluidNode",targetNode.name)
+	end
+
+	local drop=self.getNodeDrop(targetPos)
+	self.placeMiningPipe(pos,targetPos)
+	inv:add_item("dst",drop)
+
+	local scannerSlot=inv:get_stack("scanner",1)
+	if not scannerSlot:is_empty() then
+		local def=scannerSlot:get_definition()
+		if def and def._industrialtest_self then
+			local filtered=def._industrialtest_self:filter(targetPos)
+			for _,filteredPos in ipairs(filtered) do
+				drop=self.getNodeDrop(filteredPos)
+				if inv:room_for_item("dst",drop) then
+					minetest.remove_node(filteredPos)
+					inv:add_item("dst",drop)
+				end
+			end
+		end
+	end
+
+	local requiredPower=self:getRequiredPower(pos)
+	meta:set_int("level",level-1)
+	industrialtest.api.addPower(meta,-requiredPower)
+
+	return true,true
+end
+
+function industrialtest.Miner.onInventoryPut(self,pos,listname)
+	if listname=="drill" or listname=="src" then
+		self:triggerIfNeeded(pos)
+	end
+end
+
+function industrialtest.Miner.allowDrillPut(itemstack)
+	local def=itemstack:get_definition()
+	return def and def.groups and def.groups._industrialtest_miningDrill
+end
+
+function industrialtest.Miner.allowScannerPut(itemstack)
+	local def=itemstack:get_definition()
+	return def and def.groups and def.groups._industrialtest_scanner
+end
+
+function industrialtest.Miner.canContinue(self,pos,level)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local targetPos=vector.new(pos.x,level,pos.z)
+	local targetNode=minetest.get_node(targetPos)
+	if targetNode.name=="ignore" then
+		minetest.load_area(targetPos)
+		targetNode=minetest.get_node(targetPos)
+		if targetNode.name=="ignore" then
+			return false
+		end
+	end
+
+	local def=minetest.registered_nodes[targetNode.name]
+	local drop=self.getNodeDrop(vector.new(pos.x,level,pos.z))
+	return not (def and def.groups and def.groups.unbreakable) and inv:room_for_item("dst",drop)
+end
+
+function industrialtest.Miner.getRequiredPower(self,pos)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local scannerSlot=inv:get_stack("scanner",1)
+	local result=self._opPower
+	if not scannerSlot:is_empty() then
+		local def=scannerSlot:get_definition()
+		if def and def._industrialtest_self then
+			local distance=def._industrialtest_self.minerDistance or 0
+			result=result+(distance*distance-1)*self._scannerOpPower
+		end
+	end
+	return result
+end
+
+function industrialtest.Miner.getNodeDrop(pos)
+	local node=minetest.get_node(pos)
+	local def=minetest.registered_nodes[node.name]
+	if not def.pointable then
+		return ItemStack()
+	end
+	return ItemStack((def and def.drop and def.drop~="") and def.drop or node.name)
+end
+
+function industrialtest.Miner.placeMiningPipe(minerPos,pos)
+	minetest.add_node(pos,{
+		name="industrialtest:mining_pipe"
+	})
+	local meta=minetest.get_meta(pos)
+	meta:set_string("miner",minetest.serialize(minerPos))
+end
+
+function industrialtest.Miner.pullFluid(self,pos,amount)
+	local meta=minetest.get_meta(pos)
+	local lastFluidNode=meta:get_string("lastFluidNode")
+	if lastFluidNode~="" then
+		local result={
+			fluidType=lastFluidNode
+		}
+		result.remaining=industrialtest.api.nodeFluidCapacity
+		-- If everything was pulled then change to empty
+		if amount>=industrialtest.api.nodeFluidCapacity then
+			meta:set_string("lastFluidNode","")
+		end
+		return result
+	end
+	return nil
+end
+
+industrialtest.Miner:register()
+
+industrialtest.api.registerPumpTarget("industrialtest:miner","i")
+
+minetest.register_craft({
+	type="shaped",
+	output="industrialtest:miner",
+	recipe={
+		{"",industrialtest.elementKeys.chest,""},
+		{"industrialtest:electronic_circuit","industrialtest:machine_block","industrialtest:electronic_circuit"},
+		{"","industrialtest:mining_pipe",""}
+	}
+})

machines/nuclear_reactor.lua

@@ -368,7 +368,7 @@ minetest.register_craft({
 
 industrialtest.ReactorChamber=table.copy(industrialtest.Machine)
 industrialtest.internal.unpackTableInto(industrialtest.ReactorChamber,{
-	name="industrialtest:reactor_chamber",
+	name="industrialtest:nuclear_reactor_chamber",
 	description=S("Nuclear Reactor Chamber"),
 	tiles={"industrialtest_machine_block.png^industrialtest_nuclear_reactor_top.png"},
 	sounds="metal",

machines/power_storage.lua

@@ -15,9 +15,38 @@
 -- 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 inv=meta:get_inventory()
+	inv:set_size("charged",1)
+	inv:set_size("discharged",1)
+	industrialtest.ElectricMachine.onConstruct(self,pos)
+end
+
+function industrialtest.PowerStorage.getFormspec(self,pos)
+	local parentFormspec=industrialtest.ElectricMachine.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
 	local formspec={
@@ -27,95 +56,32 @@ powerStorage.getFormspec=function(pos)
 		"list[context;discharged;3,2.5;1,1]",
 		industrialtest.internal.getItemSlotBg(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 ""),
+		self.createPowerIndicatorWidget(charged,9,1),
 		"listring[context;charged]",
 		"listring[context;discharged]"
 	}
-	return table.concat(formspec,"")
+	return parentFormspec..table.concat(formspec,"")
 end
 
-powerStorage.onConstruct=function(pos,meta,inv)
-	inv:set_size("charged",1)
-	inv:set_size("discharged",1)
-end
-
-powerStorage.onTimer=function(pos,elapsed,meta,inv,config)
-	local chargedSlot=inv:get_stack("charged",1)
-	local dischargedSlot=inv:get_stack("discharged",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 meta:get_int("industrialtest.powerAmount")>0 and industrialtest.api.transferPowerToItem(meta,chargedSlot,config.flow)>0 then
-		inv:set_stack("charged",1,chargedSlot)
-		shouldRerunTimer=true
-		shouldUpdateFormspec=true
-	end
-	if dischargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(meta) and industrialtest.api.transferPowerFromItem(dischargedSlot,meta,config.flow)>0 then
-		inv:set_stack("discharged",1,dischargedSlot)
-		shouldRerunTimer=true
-		shouldUpdateFormspec=true
-	end
-
-	return shouldRerunTimer,shouldUpdateFormspec
-end
-
-powerStorage.onMetadataInventoryPut=function(pos)
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-end
-
-powerStorage.onMetadataInventoryMove=function(pos)
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-end
-
-local function registerPowerStorageNode(config)
-	industrialtest.internal.registerMachine({
-		name=config.name,
-		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={
+industrialtest.BatBox=table.copy(industrialtest.PowerStorage)
+industrialtest.internal.unpackTableInto(industrialtest.BatBox,{
+	name="industrialtest:batbox",
+	description=S("BatBox"),
 	tiles={
-				config.machineBlockTexture,
-				config.machineBlockTexture,
-				config.machineBlockTexture,
-				config.machineBlockTexture,
-				config.machineBlockTexture,
-				config.machineBlockTexture.."^industrialtest_"..config.name.."_front.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_wood_machine_block.png^industrialtest_batbox_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",
-	requiresWrench=false
+	capacity=25000,
+	flow=industrialtest.api.lvPowerFlow
 })
+
+industrialtest.BatBox:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:batbox",
@@ -126,15 +92,25 @@ minetest.register_craft({
 	}
 })
 
-registerPowerStorageNode({
-	name="cesu",
-	displayName=S("CESU"),
-	capacity=400000,
-	flow=industrialtest.api.mvPowerFlow,
+industrialtest.CESU=table.copy(industrialtest.PowerStorage)
+industrialtest.internal.unpackTableInto(industrialtest.CESU,{
+	name="industrialtest:cesu",
+	description=S("CESU"),
+	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",
-	requiresWrench=false
+	capacity=400000,
+	flow=industrialtest.api.mvPowerFlow
 })
+
+industrialtest.CESU:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:cesu",
@@ -145,15 +121,26 @@ minetest.register_craft({
 	}
 })
 
-registerPowerStorageNode({
-	name="mfe",
-	displayName=S("MFE"),
-	capacity=3000000,
-	flow=industrialtest.api.hvPowerFlow,
+industrialtest.MFE=table.copy(industrialtest.PowerStorage)
+industrialtest.internal.unpackTableInto(industrialtest.MFE,{
+	name="industrialtest:mfe",
+	description=S("MFE"),
+	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",
@@ -164,15 +151,27 @@ minetest.register_craft({
 	}
 })
 
-registerPowerStorageNode({
-	name="mfsu",
-	displayName=S("MFSU"),
-	capacity=30000000,
-	flow=industrialtest.api.evPowerFlow,
+
+industrialtest.MFSU=table.copy(industrialtest.PowerStorage)
+industrialtest.internal.unpackTableInto(industrialtest.MFSU,{
+	name="industrialtest:mfsu",
+	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=false
+	requiresWrench=true,
+	capacity=30000000,
+	flow=industrialtest.api.evPowerFlow
 })
+
+industrialtest.MFSU:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:mfsu",

machines/pump.lua

@@ -0,0 +1,407 @@
+-- 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/>.
+
+local S=minetest.get_translator("industrialtest")
+industrialtest.Pump=table.copy(industrialtest.ActivatedElectricMachine)
+industrialtest.internal.unpackTableInto(industrialtest.Pump,{
+	name="industrialtest:pump",
+	description=S("Pump"),
+	tiles={
+		"industrialtest_machine_block.png",
+		"industrialtest_machine_block.png",
+		"industrialtest_machine_block.png^industrialtest_pump_side.png",
+		"industrialtest_machine_block.png",
+		"industrialtest_machine_block.png",
+		"industrialtest_machine_block.png^industrialtest_pump_front.png"
+	},
+	sounds="metal",
+	facedir=true,
+	storageLists={
+		"src",
+		"dst",
+		"powerStorage"
+	},
+	powerLists={
+		{
+			list="powerStorage",
+			direction="i"
+		}
+	},
+	active={
+		tiles={
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png^industrialtest_pump_side.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png^industrialtest_pump_front_active.png"
+		}
+	},
+	capacity=industrialtest.api.lvPowerFlow*2,
+	flow=industrialtest.api.lvPowerFlow,
+	ioConfig="iiiiii",
+	requiresWrench=true,
+	hasPowerInput=true,
+	_fluidCapacity=5000,
+	_opPower=300,
+	_pumpTime=10
+})
+
+function industrialtest.Pump.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)
+	meta:set_float("srcTime",0)
+	industrialtest.api.addFluidStorage(meta,self._fluidCapacity)
+	self.determinePumpTargets(pos)
+	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
+end
+
+function industrialtest.Pump.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._pumpTime*100
+	local fluidType=meta:get_string("industrialtest.fluidType")
+	local fluidPercent=0
+	if meta:contains("industrialtest.fluidAmount") and meta:contains("industrialtest.fluidCapacity") then
+		fluidPercent=meta:get_int("industrialtest.fluidAmount")/meta:get_int("industrialtest.fluidCapacity")*100
+	end
+	local pumpFluid=industrialtest.api.getPumpFluid(fluidType)
+	local tile=(pumpFluid and pumpFluid.texture or "industrialtest_gui_fluid_bg.png")
+	local formspec={
+		"list[context;src;3.2,1.7;1,1]",
+		industrialtest.internal.getItemSlotBg(3.2,1.7,1,1),
+		"list[context;dst;4.6,1.7;1,1]",
+		industrialtest.internal.getItemSlotBg(4.6,1.7,1,1),
+		"list[context;powerStorage;3.9,3.7;1,1]",
+		industrialtest.internal.getItemSlotBg(3.9,3.7,1,1),
+		(powerPercent>0 and "image[3.9,2.7;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
+		 or "image[3.9,2.7;1,1;industrialtest_gui_electricity_bg.png]"),
+		(srcPercent>0 and "image[6.7,2.7;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png]"
+		 or "image[6.7,2.7;1,1;gui_furnace_arrow_bg.png]"),
+		(fluidPercent>0 and "image[7.7,2.7;1,1;industrialtest_gui_fluid_bg.png^[lowpart:"..fluidPercent..":"..tile.."]" or "image[7.7,2.7;1,1;industrialtest_gui_fluid_bg.png]"),
+		"label[3.2,1.35;"..S("Input").."]",
+		"label[4.6,1.35;"..S("Output").."]",
+		"listring[context;src]",
+		"listring[context;dst]"
+	}
+	return parentFormspec..table.concat(formspec,"")
+end
+
+function industrialtest.Pump.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.Pump.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
+	if listname=="dst" then
+		return 0
+	end
+	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
+end
+
+function industrialtest.Pump.allowMetadataInventoryTake(self,pos,listname,index,stack,player)
+	if listname=="src" then
+		local meta=minetest.get_meta(pos)
+		local inv=meta:get_inventory()
+		local srcSlot=inv:get_stack("src",1)
+		if stack:get_count()==srcSlot:get_count() and not meta:get_int("hasOutputTarget") then
+			meta:set_float("srcTime",0)
+			self:updateFormspec(pos)
+		end
+	end
+	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryTake(self,pos,listname,index,stack,player)
+end
+
+function industrialtest.Pump.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+	if fromList=="src" then
+		local meta=minetest.get_meta(pos)
+		local inv=meta:get_inventory()
+		local srcSlot=inv:get_stack("src",1)
+		if count==srcSlot:get_count() and not meta:get_int("hasOutputTarget") then
+			meta:set_float("srcTime",0)
+			self:updateFormspec(pos)
+		end
+	elseif toList=="src" then
+		self:triggerIfNeeded(pos)
+	end
+	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+end
+
+function industrialtest.Pump.onMetadataInventoryPut(self,pos,listname,index,stack)
+	if listname=="src" then
+		self:triggerIfNeeded(pos)
+	end
+	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
+end
+
+function industrialtest.Miner.onMetadataInventoryTake(self,pos,listname,index,stack)
+	if listname=="dst" then
+		self:triggerIfNeeded(pos)
+	end
+end
+
+function industrialtest.Pump.shouldActivate(self,pos)
+	local meta=minetest.get_meta(pos)
+	if meta:get_int("industrialtest.powerAmount")<self._opPower then
+		return false
+	end
+
+	local hasInput=false
+	local nodeUnder=minetest.get_node(vector.offset(pos,0,-1,0))
+	local fluidAmount=meta:get_int("industrialtest.fluidAmount")
+	if fluidAmount>0 then
+		hasInput=true
+	else
+		-- Check if there is node that can be pumped under pump
+		if industrialtest.api.getPumpFluid(nodeUnder.name) then
+			hasInput=true
+		end
+	end
+
+	-- Check if any input target can provide with fluid
+	if not hasInput and meta:get_int("hasInputTarget")>0 then
+		local polledTargets=self.pollInputTargets(pos)
+		hasInput=#polledTargets>0
+	end
+
+	if not hasInput then
+		return false
+	end
+
+	local hasOutput=false
+	-- First check if pump can push into any neighour node
+	if meta:get_int("hasOutputTarget") then
+		local outputTargets=minetest.deserialize(meta:get_string("outputTargets"))
+		for _,target in ipairs(outputTargets) do
+			local node=minetest.get_node(target)
+			local def=minetest.registered_nodes[node.name]
+			hasOutput=(def and def._industrialtest_self and def._industrialtest_self:canPushFluid(target,nodeUnder.name,fluidAmount))
+			if hasOutput then
+				break
+			end
+		end
+	end
+
+	-- Check if it's possible to pump fluid into item
+	if not hasOutput then
+		local inv=meta:get_inventory()
+		local srcSlot=inv:get_stack("src",1)
+		if not srcSlot:is_empty() then
+			local def=srcSlot:get_definition()
+			if def.groups._industrialtest_simpleFluidStorage and def._industrialtest_simpleFluidStorageCapacity and fluidAmount>=def._industrialtest_simpleFluidStorageCapacity and
+				def._industrialtest_getResultingFluidStorageItemByNode then
+				local fluidType=meta:get_string("industrialtest.fluidType")
+				local resulting=def._industrialtest_getResultingFluidStorageItemByNode(fluidType)
+				if resulting then
+					local dstSlot=inv:get_stack("dst",1)
+					hasOutput=dstSlot:item_fits(ItemStack(resulting.name))
+				end
+			end
+		end
+	end
+
+	-- Check if pump storage is not full
+	if not hasOutput then
+		local fluidCapacity=meta:get_int("industrialtest.fluidCapacity")
+		hasOutput=fluidCapacity-fluidAmount>=industrialtest.api.nodeFluidCapacity
+	end
+
+	return hasOutput
+end
+
+function industrialtest.Pump.shouldDeactivate(self,pos)
+	return not self:shouldActivate(pos)
+end
+
+function industrialtest.Pump.afterDeactivation(self,pos)
+	-- If machine was deactivated then make sure to update formspec
+	local meta=minetest.get_meta(pos)
+	meta:set_float("srcTime",0)
+	self:updateFormspec(pos)
+end
+
+function industrialtest.Pump.activeUpdate(self,pos,elapsed,meta,inv)
+	local nodeUnderPos=vector.offset(pos,0,-1,0)
+	local nodeUnder=minetest.get_node(nodeUnderPos)
+	local fluidAmount=meta:get_int("industrialtest.fluidAmount")
+	local fluidCapacity=meta:get_int("industrialtest.fluidCapacity")
+	local shouldUpdateFormspec=false
+
+	-- First try to pump fluid under
+	-- Check if there is node that can be pumped under pump
+	if fluidCapacity-fluidAmount>=industrialtest.api.nodeFluidCapacity and industrialtest.api.getPumpFluid(nodeUnder.name) then
+		local srcTime=meta:get_float("srcTime")+elapsed*industrialtest.api.getMachineSpeed(meta)
+		if srcTime>=self._pumpTime then
+			fluidAmount=fluidAmount+industrialtest.api.nodeFluidCapacity
+			meta:set_string("industrialtest.fluidType",nodeUnder.name)
+			meta:set_int("industrialtest.fluidAmount",fluidAmount)
+			minetest.remove_node(nodeUnderPos)
+			srcTime=0
+		end
+		industrialtest.api.addPower(meta,-self._opPower)
+		meta:set_float("srcTime",srcTime)
+		shouldUpdateFormspec=true
+	end
+
+	if meta:get_int("hasInputTarget")>0 then
+		local polledTargets=self.pollInputTargets(pos)
+		local fluidType=meta:get_string("industrialtest.fluidType")
+		for _,target in ipairs(polledTargets) do
+			local moved=math.min(fluidCapacity-fluidAmount,target.fluidInfo.remaining)
+			fluidAmount=fluidAmount+moved
+			target.pullFluid(moved)
+			meta:set_string("industrialtest.fluidType",target.fluidInfo.fluidType)
+			shouldUpdateFormspec=true
+			if fluidCapacity-fluidAmount<=0 then
+				break
+			end
+		end
+		meta:set_int("industrialtest.fluidAmount",fluidAmount)
+	end
+
+	-- Try to push fluid into item if available
+	local inv=meta:get_inventory()
+	local srcSlot=inv:get_stack("src",1)
+	if not srcSlot:is_empty() then
+		local def=srcSlot:get_definition()
+		if def.groups._industrialtest_simpleFluidStorage and def._industrialtest_simpleFluidStorageCapacity and fluidAmount>=def._industrialtest_simpleFluidStorageCapacity and
+			def._industrialtest_getResultingFluidStorageItemByNode then
+			local fluidType=meta:get_string("industrialtest.fluidType")
+			local resulting=def._industrialtest_getResultingFluidStorageItemByNode(fluidType)
+			if resulting then
+				local dstSlot=inv:get_stack("dst",1)
+				local resultingStack=ItemStack(resulting.name)
+				if dstSlot:item_fits(resultingStack) then
+					dstSlot:add_item(resultingStack)
+					inv:set_stack("dst",1,dstSlot)
+					srcSlot:take_item()
+					inv:set_stack("src",1,srcSlot)
+					fluidAmount=fluidAmount-def._industrialtest_simpleFluidStorageCapacity
+					meta:set_int("industrialtest.fluidAmount",fluidAmount)
+					shouldUpdateFormspec=true
+				end
+			end
+		end
+	end
+
+	-- Try to push fluid into neighbour target
+	if meta:get_int("hasOutputTarget")>0 then
+		local outputTargets=minetest.deserialize(meta:get_string("outputTargets"))
+		for _,targetPos in ipairs(outputTargets) do
+			local targetNode=minetest.get_node(targetPos)
+			local targetDef=minetest.registered_nodes[targetNode.name]
+			local fluidType=meta:get_string("industrialtest.fluidType")
+			if targetDef and targetDef._industrialtest_self and targetDef._industrialtest_self.canPushFluid and
+				targetDef._industrialtest_self.onPumpFluidPush and targetDef._industrialtest_self:canPushFluid(targetPos,fluidType,fluidAmount) then
+				fluidAmount=targetDef._industrialtest_self:onPumpFluidPush(targetPos,pos,fluidType,fluidAmount)
+			end
+		end
+		meta:set_int("industrialtest.fluidAmount",fluidAmount)
+	end
+
+	return shouldUpdateFormspec
+end
+
+function industrialtest.Pump.action(self,pos)
+	self.determinePumpTargets(pos)
+	self:triggerIfNeeded(pos)
+end
+
+-- Scans neighbour positions for pump targets
+function industrialtest.Pump.determinePumpTargets(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)
+	}
+	local inputTargets={}
+	local outputTargets={}
+	for _,neighbour in ipairs(neighbourPositions) do
+		local node=minetest.get_node(neighbour)
+		local targetDef=industrialtest.api.getPumpTarget(node.name)
+		if targetDef then
+			if targetDef.direction=="i" then
+				table.insert(inputTargets,neighbour)
+			elseif targetDef.direction=="o" then
+				table.insert(outputTargets,neighbour)
+			end
+		end
+	end
+	local meta=minetest.get_meta(pos)
+	meta:set_string("inputTargets",minetest.serialize(inputTargets))
+	meta:set_int("hasInputTarget",#inputTargets>0 and 1 or 0)
+	meta:set_string("outputTargets",minetest.serialize(outputTargets))
+	meta:set_int("hasOutputTarget",#outputTargets>0 and 1 or 0)
+end
+
+-- \brief Checks all input targets if they have any fluid incoming
+-- \param pos vector
+-- \returns table
+function industrialtest.Pump.pollInputTargets(pos)
+	local meta=minetest.get_meta(pos)
+	local inputTargets=minetest.deserialize(meta:get_string("inputTargets"))
+	local fluidType=meta:get_string("industrialtest.fluidType")
+	local result={}
+	for _,targetPos in ipairs(inputTargets) do
+		local targetNode=minetest.get_node(targetPos)
+		local targetDef=minetest.registered_nodes[targetNode.name]
+		if targetDef and targetDef._industrialtest_self and targetDef._industrialtest_self.pullFluid then
+			local fluidInfo=targetDef._industrialtest_self:pullFluid(targetPos,0)
+			if fluidInfo and (fluidInfo.fluidType==fluidType or fluidType=="ignore") then
+				table.insert(result,{
+					pos=targetPos,
+					fluidInfo=fluidInfo,
+					pullFluid=function(amount)
+						return targetDef._industrialtest_self:pullFluid(targetPos,amount)
+					end
+				})
+				fluidType=fluidInfo.fluidType
+			end
+		end
+	end
+	return result
+end
+
+industrialtest.Pump:register()
+
+minetest.register_abm({
+	label="Pump pumping",
+	nodenames={"industrialtest:pump"},
+	interval=industrialtest.config.updateDelay,
+	chance=1,
+	action=function(pos)
+		industrialtest.Pump:action(pos)
+	end
+})
+
+minetest.register_craft({
+	type="shaped",
+	output="industrialtest:pump",
+	recipe={
+		{"industrialtest:empty_cell","industrialtest:electronic_circuit","industrialtest:empty_cell"},
+		{"industrialtest:empty_cell","industrialtest:machine_block","industrialtest:empty_cell"},
+		{"industrialtest:mining_pipe",industrialtest.elementKeys.treetap,"industrialtest:mining_pipe"}
+	}
+})

machines/rotary_macerator.lua

@@ -15,12 +15,68 @@
 -- 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
+})
 
-local rotaryMacerator={}
-rotaryMacerator.opPower=60
-rotaryMacerator.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
 
-rotaryMacerator.getFormspec=function(pos)
+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")
@@ -47,153 +103,145 @@ rotaryMacerator.getFormspec=function(pos)
 		"listring[context;src]",
 		"listring[context;dst]"
 	}
-	return table.concat(formspec,"")
+	return parentFormspec..table.concat(formspec,"")
 end
 
-rotaryMacerator.onConstruct=function(pos,meta,inv)
-	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)
-end
-
-rotaryMacerator.onTimer=function(pos,elapsed,meta,inv)
+function industrialtest.RotaryMacerator.update(self,pos,elapsed,meta,inv)
 	local shouldRerunTimer=false
 	local shouldUpdateFormspec=false
-	local srcSlot=inv:get_stack("src",1)
-	local modifierSlot=inv:get_stack("modifier",1)
-	local dstSlot=inv:get_stack("dst",1)
 	local rpm=meta:get_int("rpm")
 	local maintainSpeed=meta:get_int("maintainSpeed")
-
-	shouldRerunTimer,shouldUpdateFormspec=industrialtest.internal.chargeFromPowerStorageItem(meta,inv)
 	local powerAmount=meta:get_int("industrialtest.powerAmount")
 
-	if maintainSpeed==1 and powerAmount>=rotaryMacerator.maintainSpeedOpPower then
+	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,-rotaryMacerator.maintainSpeedOpPower)
+		industrialtest.api.addPower(meta,-self._maintainSpeedOpPower)
 		shouldRerunTimer=true
 	elseif rpm>0 then
 		meta:set_int("rpm",math.max(rpm-1000*elapsed,0))
-		shouldRerunTimer=shouldRerunTimer or rpm>0
+		shouldRerunTimer=rpm>0
 		shouldUpdateFormspec=true
 	end
 	
-	if powerAmount>=rotaryMacerator.opPower and not srcSlot:is_empty() then
-		local result=industrialtest.api.getMaceratorRecipeResult(srcSlot:get_name())
-		if result then
-			meta:set_float("srcTime",0)
-			meta:set_float("maxSrcTime",result.time)
-			minetest.swap_node(pos,{
-				name="industrialtest:rotary_macerator_active",
-				param2=minetest.get_node(pos).param2
-			})
-			minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-			return false,shouldUpdateFormspec
-		end
-	end
-	
 	return shouldRerunTimer,shouldUpdateFormspec
 end
 
-rotaryMacerator.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,count)
+function industrialtest.RotaryMacerator.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,count)
 	if toList=="dst" then
 		return 0
 	end
-	return count
+	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 end
 
-rotaryMacerator.allowMetadataInventoryPut=function(pos,listname,index,stack)
+function industrialtest.RotaryMacerator.allowMetadataInventoryPut(self,pos,listname,index,stack)
 	if listname=="dst" then
 		return 0
 	end
-	return stack:get_count()
+	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack)
 end
 
-rotaryMacerator.onMetadataInventoryMove=function(pos)
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-end
-
-rotaryMacerator.onMetadataInventoryPut=function(pos)
-	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-end
-
-rotaryMacerator.onMetadataInventoryTake=function(pos,listname)
-	if listname=="dst" then
-		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+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
 
-rotaryMacerator.activeOnTimer=function(pos,elapsed,meta,inv)
+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 modifierSlot=inv:get_stack("modifier",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*rotaryMacerator.opPower*speed
+	local requiredPower=elapsed*self._opPower*speed
 
-	industrialtest.internal.chargeFromPowerStorageItem(meta,inv)
-
-	if srcSlot:is_empty() or powerAmount<requiredPower then
-		meta:set_float("srcTime",0)
-		meta:set_float("maxSrcTime",0)
-		minetest.swap_node(pos,{
-			name="industrialtest:rotary_macerator",
-			param2=minetest.get_node(pos).param2
-		})
-		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-		return false,true
-	end
-
-	local result
-	local modified=false
-	if not modifierSlot:is_empty() then
-		result=industrialtest.api.getRotaryMaceratorModifier(srcSlot:get_name(),modifierSlot:get_name())
-	end
-	if result then
-		modified=true
-	else
-		result=industrialtest.api.getMaceratorRecipeResult(srcSlot:get_name())
-	end
-	local resultStack=ItemStack(result.output)
-	if not dstSlot:item_fits(resultStack) then
-		meta:set_float("srcTime",0)
-		meta:set_float("maxSrcTime",0)
-		minetest.swap_node(pos,{
-			name="industrialtest:rotary_macerator",
-			param2=minetest.get_node(pos).param2
-		})
-		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-		return false,true
-	end
+	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>=meta:get_float("maxSrcTime") then
+	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)
-		meta:set_float("maxSrcTime",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
@@ -205,7 +253,12 @@ rotaryMacerator.activeOnTimer=function(pos,elapsed,meta,inv)
 				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
@@ -215,55 +268,29 @@ rotaryMacerator.activeOnTimer=function(pos,elapsed,meta,inv)
 
 	industrialtest.api.addPower(meta,-requiredPower)
 
-	return true,true
+	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
 
-industrialtest.internal.registerMachine({
-	name="rotary_macerator",
-	displayName=S("Rotary Macerator"),
-	capacity=industrialtest.api.lvPowerFlow*2,
-	getFormspec=rotaryMacerator.getFormspec,
-	flow=industrialtest.api.lvPowerFlow,
-	ioConfig="iiiiii",
-	requiresWrench=true,
-	registerActiveVariant=true,
-	sounds="metal",
-	powerSlots={"powerStorage"},
-	storageSlots={"src","modifier","powerStorage","dst","upgrades"},
-	groups={
-		_industrialtest_hasPowerInput=1
-	},
-	customKeys={
-		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"
-		},
-		paramtype2="facedir",
-		legacy_facedir_simple=true
-	},
-	activeCustomKeys={
-		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"
-		}
-	},
-	onConstruct=rotaryMacerator.onConstruct,
-	onTimer=rotaryMacerator.onTimer,
-	allowMetadataInventoryMove=rotaryMacerator.allowMetadataInventoryMove,
-	allowMetadataInventoryPut=rotaryMacerator.allowMetadataInventoryPut,
-	onMetadataInventoryPut=rotaryMacerator.onMetadataInventoryPut,
-	onMetadataInventoryMove=rotaryMacerator.onMetadataInventoryMove,
-	onMetadataInventoryTake=rotaryMacerator.onMetadataInventoryTake,
-	activeOnTimer=rotaryMacerator.activeOnTimer
-})
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:rotary_macerator",

machines/simple_electric_item_processor.lua

@@ -14,6 +14,8 @@
 -- 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.SimpleElectricItemProcessor=table.copy(industrialtest.ActivatedElectricMachine)
 industrialtest.internal.unpackTableInto(industrialtest.SimpleElectricItemProcessor,{
 	facedir=true,
@@ -51,7 +53,9 @@ function industrialtest.SimpleElectricItemProcessor.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 recipeOverride=self.isRecipeOverride(meta)
 	local formspec={
+		(recipeOverride and "label[3.4,1.5;"..S("Recipe override: @1", minetest.registered_items[recipeOverride].description).."]" or ""),
 		"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]"
@@ -107,8 +111,8 @@ function industrialtest.SimpleElectricItemProcessor.onMetadataInventoryMove(self
 	end
 end
 
-function industrialtest.SimpleElectricItemProcessor.onMetadataInventoryPut(self,pos)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos)
+function industrialtest.SimpleElectricItemProcessor.onMetadataInventoryPut(self,pos,listname,index,stack)
+	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
 	self:triggerIfNeeded(pos)
 end
 
@@ -151,7 +155,8 @@ function industrialtest.SimpleElectricItemProcessor.shouldActivate(self,pos)
 		local output=self:getCraftResult(srcSlot)
 		return output and output.time>0 and inv:room_for_item("dst",output.item)
 	end
-	return false
+
+	return meta:contains("recipeOverride") and meta:contains("recipeOverrideMaxTime") and meta:get_string("recipeOverride")~=""
 end
 
 function industrialtest.SimpleElectricItemProcessor.shouldDeactivate(self,pos)
@@ -164,6 +169,10 @@ function industrialtest.SimpleElectricItemProcessor.shouldDeactivate(self,pos)
 		return true
 	end
 
+	if meta:contains("recipeOverride") and meta:contains("recipeOverrideMaxTime") and meta:get_string("recipeOverride")~="" then
+		return false
+	end
+
 	local srcSlot=inv:get_stack("src",1)
 	if srcSlot:is_empty() then
 		return true
@@ -179,11 +188,15 @@ function industrialtest.SimpleElectricItemProcessor.activeUpdate(self,pos,elapse
 	local srcTime=0
 	local maxSrcTime
 	if meta:get_float("maxSrcTime")<=0 then
+		local recipeOverride=self.isRecipeOverride(meta)
+		if recipeOverride then
+			maxSrcTime=meta:get_int("recipeOverrideMaxTime")
+		else
 			local output=self:getCraftResult(srcSlot)
 			maxSrcTime=output.time*self.efficiency
+		end
 		meta:set_float("srcTime",0)
 		meta:set_float("maxSrcTime",maxSrcTime)
-		shouldUpdateFormspec=true
 	else
 		srcTime=meta:get_float("srcTime")
 		maxSrcTime=meta:get_float("maxSrcTime")
@@ -196,6 +209,11 @@ function industrialtest.SimpleElectricItemProcessor.activeUpdate(self,pos,elapse
 	meta:set_int("srcTime",srcTime)
 
 	if srcTime>=maxSrcTime then
+		local recipeOverride=self.isRecipeOverride(meta)
+		if recipeOverride then
+			inv:add_item("dst",ItemStack(recipeOverride))
+			meta:set_string("recipeOverride","")
+		else
 			local output=self:getCraftResult(srcSlot)
 			local usedItems=srcSlot:get_count()-output.src:get_count()
 			local multiplier=1
@@ -206,15 +224,23 @@ function industrialtest.SimpleElectricItemProcessor.activeUpdate(self,pos,elapse
 				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
+		meta:set_float("srcTime",-1)
+		meta:set_float("maxSrcTime",0)
+	end
 
 	return true
 end
 
+function industrialtest.SimpleElectricItemProcessor.isRecipeOverride(meta)
+	if meta:contains("recipeOverride") and meta:contains("recipeOverrideMaxTime") and meta:get_string("recipeOverride")~="" then
+		return meta:get_string("recipeOverride")
+	end
+	return false
+end
+
 function industrialtest.SimpleElectricItemProcessor.getCraftResult(self,itemstack)
 	-- Dummy method
 end

machines/solar_panel_generator.lua

@@ -15,9 +15,36 @@
 -- 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,{
+	sounds="metal",
+	requiresWrench=true,
+	storageLists={
+		"charged"
+	},
+	powerLists={
+		{
+			list="charged",
+			direction="o"
+		}
+	},
+	hasPowerOutput=true,
+	ioConfig="oooooo",
+	multiplier=1
+})
 
-solarPanel.getFormspec=function(pos)
+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
+
+function industrialtest.SolarPanelBase.getFormspec(self,pos)
+	local parentFormspec=industrialtest.ElectricMachine.getFormspec(self,pos)
 	local amount=minetest.get_natural_light(vector.offset(pos,0,1,0))/15.0
 	local charging=amount>0.5
 	local formspec={
@@ -27,71 +54,48 @@ solarPanel.getFormspec=function(pos)
 		 or "image[4.7,2.8;1,1;industrialtest_gui_sun_bg.png]"),
 		"listring[context;charged]"
 	}
-	return table.concat(formspec,"")
+	return parentFormspec..table.concat(formspec,"")
 end
 
-solarPanel.onConstruct=function(pos,meta,inv)
-	inv:set_size("charged",1)
-	meta:set_float("prevAmount",0)
+function industrialtest.SolarPanelBase.register(self)
+	industrialtest.ElectricMachine.register(self)
+	table.insert(solarPanels,self.name)
 end
 
-solarPanel.onTimer=function(pos,elapsed,meta,inv,config)
-	local chargedSlot=inv:get_stack("charged",1)
-	local shouldUpdateFormspec=false
+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*self.multiplier))>0 then
+			self:updateFormspec(pos)
 		end
-	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.internal.registerMachine({
-		name=config.name,
-		displayName=config.displayName,
-		getFormspec=solarPanel.getFormspec,
-		capacity=config.capacity,
-		flow=config.flow,
-		ioConfig="oooooo",
-		requiresWrench=true,
-		registerActiveVariant=false,
-		powerSlots={"charged"},
-		storageSlots={"charged"},
-		sounds="metal",
-		groups={
-			_industrialtest_hasPowerOutput=1
-		},
-		customKeys={
+industrialtest.SolarPanel=table.copy(industrialtest.SolarPanelBase)
+industrialtest.internal.unpackTableInto(industrialtest.SolarPanel,{
+	name="industrialtest:solar_panel",
+	description=S("Solar Panel"),
 	tiles={
-				"industrialtest_machine_block.png^industrialtest_"..config.name.."_top.png",
+		"industrialtest_machine_block.png^industrialtest_solar_panel_top.png",
+		"industrialtest_machine_block.png",
+		"industrialtest_machine_block.png",
+		"industrialtest_machine_block.png",
+		"industrialtest_machine_block.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",
@@ -102,12 +106,25 @@ minetest.register_craft({
 	}
 })
 
-registerSolarPanelGenerator({
-	name="lv_solar_array",
-	displayName=S("LV Solar Array"),
+industrialtest.LVSolarArray=table.copy(industrialtest.SolarPanelBase)
+industrialtest.internal.unpackTableInto(industrialtest.LVSolarArray,{
+	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
+	flow=industrialtest.api.lvPowerFlow,
+	multiplier=1.5
 })
+
+industrialtest.LVSolarArray:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:lv_solar_array",
@@ -118,12 +135,24 @@ minetest.register_craft({
 	}
 })
 
-registerSolarPanelGenerator({
-	name="mv_solar_array",
-	displayName=S("MV Solar Array"),
+industrialtest.MVSolarArray=table.copy(industrialtest.SolarPanelBase)
+industrialtest.internal.unpackTableInto(industrialtest.MVSolarArray,{
+	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",
@@ -134,12 +163,25 @@ minetest.register_craft({
 	}
 })
 
-registerSolarPanelGenerator({
-	name="hv_solar_array",
-	displayName=S("HV Solar Array"),
+
+industrialtest.HVSolarArray=table.copy(industrialtest.SolarPanelBase)
+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",
@@ -149,3 +191,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.config.updateDelay,
+	chance=1,
+	action=function(pos,node)
+		local def=minetest.registered_nodes[node.name]
+		def._industrialtest_self:action(pos)
+	end
+})

machines/tool_workshop.lua

@@ -15,9 +15,61 @@
 -- 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,{
+	name="industrialtest:tool_workshop",
+	description=S("Tool Workshop"),
+	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_tool_workshop_front.png",
+	},
+	sounds="metal",
+	requiresWrench=true,
+	facedir=true,
+	storageLists={
+		"src",
+		"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_tool_workshop_front_active.png",
+		}
+	},
+	capacity=15000,
+	flow=industrialtest.api.hvPowerFlow,
+	hasPowerInput=true,
+	ioConfig="iiiiii",
+	_opPower=10000,
+	_efficiency=200
+})
 
-toolWorkshop.getFormspec=function(pos)
+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={
@@ -31,79 +83,69 @@ toolWorkshop.getFormspec=function(pos)
 		industrialtest.internal.getItemSlotBg(9,0.9,1,4),
 		"listring[context;src]"
 	}
-	return table.concat(formspec,"")
+	return parentFormspec..table.concat(formspec,"")
 end
 
-toolWorkshop.onConstruct=function(pos,meta,inv)
-	inv:set_size("powerStorage",1)
-	inv:set_size("src",1)
-	inv:set_size("upgrades",4)
+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
 
-toolWorkshop.onTimer=function(pos,elapsed,meta,inv)
-	local powerStorageSlot=inv:get_stack("powerStorage",1)
+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)
-	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
+	return not toolSlot:is_empty() and self.isTool(toolSlot) and toolSlot:get_wear()>0
 end
 
-toolWorkshop.activeOnTimer=function(pos,elapsed,meta,inv)
-	local powerStorageSlot=inv:get_stack("powerStorage",1)
+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=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)
+	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)
-		shouldRerunTimer=true
-		shouldUpdateFormspec=true
-	else
-		minetest.swap_node(pos,{
-			name="industrialtest:tool_workshop",
-			param2=minetest.get_node(pos).param2
-		})
-	end
 
-	return shouldRerunTimer,shouldUpdateFormspec
+	return true
 end
 
-local function isTool(stack)
+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
@@ -111,76 +153,8 @@ local function isTool(stack)
 	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=="src" 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
+industrialtest.ToolWorkshop:register()
 
-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={"src"},
-	sounds="metal",
-	groups={
-		_industrialtest_hasPowerInput=1
-	},
-	customKeys={
-		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_tool_workshop_front.png",
-			"industrialtest_advanced_machine_block.png"
-		},
-		paramtype2="facedir",
-		legacy_facedir_simple=true
-	},
-	activeCustomKeys={
-		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_tool_workshop_front_active.png",
-			"industrialtest_advanced_machine_block.png"
-		},
-	},
-	onConstruct=toolWorkshop.onConstruct,
-	onTimer=toolWorkshop.onTimer,
-	activeOnTimer=toolWorkshop.activeOnTimer,
-	allowMetadataInventoryMove=toolWorkshop.allowMetadataInventoryMove,
-	allowMetadataInventoryPut=toolWorkshop.allowMetadataInventoryPut,
-	onMetadataInventoryPut=toolWorkshop.metadataChange,
-	onMetadataInventoryMove=toolWorkshop.metadataChange
-})
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:tool_workshop",

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={}
-
-transformer.onPowerFlow=function(pos,side,amount)
-	local normalized=industrialtest.api.normalizeSide(pos,side)
-	local def=minetest.registered_nodes[minetest.get_node(pos).name]
-	if normalized~=5 and amount>def._industrialtest_lowerFlow then
-		minetest.remove_node(pos)
-		industrialtest.internal.explode(pos,2)
-	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,
+industrialtest.Transformer=table.copy(industrialtest.ElectricMachine)
+industrialtest.internal.unpackTableInto(industrialtest.Transformer,{
 	withoutFormspec=true,
-		onTimer=transformer.onTimer
-	})
+	facedir=true,
+	storageLists={},
+	powerLists={},
+	hasPowerInput=true,
+	hasPowerOutput=true
+})
+
+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
 
-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.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({
-	name="mv_transformer",
-	displayName=S("MV Transformer"),
-	machineBlockTexture="industrialtest_machine_block.png",
+industrialtest.MVTransformer=table.copy(industrialtest.Transformer)
+industrialtest.internal.unpackTableInto(industrialtest.MVTransformer,{
+	name="industrialtest:mv_transformer",
+	description=S("MV Transformer"),
+	sounds="metal",
 	requiresWrench=true,
-	lowerFlow=industrialtest.api.mvPowerFlow,
-	upperFlow=industrialtest.api.hvPowerFlow,
-	sounds="metal"
+	tiles={
+		"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_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({
-	name="hv_transformer",
-	displayName=S("HV Transformer"),
-	machineBlockTexture="industrialtest_machine_block.png",
+industrialtest.HVTransformer=table.copy(industrialtest.Transformer)
+industrialtest.internal.unpackTableInto(industrialtest.HVTransformer,{
+	name="industrialtest:hv_transformer",
+	description=S("HV Transformer"),
+	sounds="metal",
 	requiresWrench=true,
-	lowerFlow=industrialtest.api.hvPowerFlow,
-	upperFlow=industrialtest.api.evPowerFlow,
-	sounds="metal"
+	tiles={
+		"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_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({
-	name="ev_transformer",
-	displayName=S("EV Transformer"),
-	machineBlockTexture="industrialtest_machine_block.png",
+industrialtest.EVTransformer=table.copy(industrialtest.Transformer)
+industrialtest.internal.unpackTableInto(industrialtest.EVTransformer,{
+	name="industrialtest:ev_transformer",
+	description=S("EV Transformer"),
+	sounds="metal",
 	requiresWrench=true,
-	lowerFlow=industrialtest.api.evPowerFlow,
-	upperFlow=industrialtest.api.ivPowerFlow,
-	sounds="metal"
+	tiles={
+		"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_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",

machines/wind_mill.lua

@@ -15,9 +15,46 @@
 -- 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 inv=meta:get_inventory()
+	inv:set_size("charged",1)
+	meta:set_int("prevCharging",0)
+	meta:set_int("charging",0)
+	industrialtest.ElectricMachine.onConstruct(self,pos)
+end
+
+function industrialtest.WindMill.getFormspec(self,pos)
+	local parentFormspec=industrialtest.ElectricMachine.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	local charging=meta:get_int("charging")
 	local formspec={
@@ -27,18 +64,11 @@ windMill.getFormspec=function(pos)
 		 or "image[4.7,3;1,1;industrialtest_gui_wind_bg.png]"),
 		"listring[context;charged]"
 	}
-	return table.concat(formspec,"")
+	return parentFormspec..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)
-end
-
-windMill.onTimer=function(pos,elapsed,meta,inv)
-	local chargedSlot=inv:get_stack("charged",1)
-	local shouldUpdateFormspec=false
+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)
@@ -46,13 +76,14 @@ windMill.onTimer=function(pos,elapsed,meta,inv)
 		local dimMax=31000
 		local dim=mcl_worlds.pos_to_dimension(pos)
 		if dim=="overworld" then
-			dimMax=mcl_vars.mg_overworld_max
+			dimMax=mcl_vars.mg_overworld_max_official
 		elseif dim=="nether" then
 			dimMax=mcl_vars.mg_nether_max
 		elseif dim=="end" then
-			dimMax=mcl_vars.mg_end_max
+			dimMax=mcl_vars.mg_end_max_official
 		end
-		charging=math.max(mcl_worlds.layer_to_y(pos.y,dim),0)/dimMax
+		local layer,_=mcl_worlds.y_to_layer(pos.y)
+		charging=math.min(math.max((layer or 0),0)/dimMax,1.0)
 	end
 	local neighbourPositions={
 		vector.offset(pos,-1,0,0),
@@ -67,48 +98,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({
-	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
-})
+industrialtest.WindMill:register()
 
 minetest.register_craft({
 	type="shaped",
@@ -119,3 +119,13 @@ minetest.register_craft({
 		{"","industrialtest:refined_iron_ingot",""}
 	}
 })
+
+minetest.register_abm({
+	name="Wind mill updating",
+	nodenames={"industrialtest:wind_mill"},
+	interval=industrialtest.config.updateDelay,
+	chance=1,
+	action=function(pos)
+		industrialtest.WindMill:action(pos)
+	end
+})

nodes.lua

@@ -354,6 +354,19 @@ if not industrialtest.mods.mclRubber then
 					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)
+		definition._on_bone_meal=function(itemstack,user,pointed)
+			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
 		minetest.register_abm({
 			label="Rubber sapling growing",
 			nodenames={"industrialtest:rubber_sapling"},
@@ -379,23 +392,6 @@ if not industrialtest.mods.mclRubber then
 				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
@@ -493,3 +489,141 @@ minetest.register_craft({
 		{industrialtest.elementKeys.glass,"industrialtest:advanced_alloy",industrialtest.elementKeys.glass}
 	}
 })
+
+-- \brief Function which should be called after iron fence was constructed
+-- \param pos vector
+-- \returns nil
+local function ironFenceOnConstruct(pos)
+	local neighbours={
+		vector.offset(pos,0,-1,0),
+		vector.offset(pos,0,1,0)
+	}
+	for _,neighbourPosition in ipairs(neighbours) do
+		local meta=minetest.get_meta(neighbourPosition)
+		if meta:contains("magnetizerPosition") then
+			local magnetizerPosition=minetest.deserialize(meta:get_string("magnetizerPosition"))
+			industrialtest.Magnetizer:determineFenceRail(magnetizerPosition)
+			industrialtest.Magnetizer:determinePowerCapacity(magnetizerPosition)
+			industrialtest.Magnetizer:updateFormspec(magnetizerPosition)
+			industrialtest.Magnetizer:requestPower(magnetizerPosition)
+			break
+		end
+	end
+
+	neighbours={
+		vector.offset(pos,1,0,0),
+		vector.offset(pos,-1,0,0),
+		vector.offset(pos,0,0,1),
+		vector.offset(pos,0,0,-1)
+	}
+	for _,neighbourPosition in ipairs(neighbours) do
+		local neighbourNode=minetest.get_node(neighbourPosition)
+		if neighbourNode.name=="industrialtest:magnetizer" then
+			local meta=minetest.get_meta(neighbourPosition)
+			if not meta:contains("railPosition") then
+				industrialtest.Magnetizer:determineFenceRail(neighbourPosition)
+				industrialtest.Magnetizer:determinePowerCapacity(neighbourPosition)
+				industrialtest.Magnetizer:updateFormspec(neighbourPosition)
+				industrialtest.Magnetizer:requestPower(neighbourPosition)
+				break
+			end
+		end
+	end
+end
+
+-- \brief Function which should be called before iron fence was removed
+-- \param pos vector
+-- \returns nil
+local function ironFenceOnDestruct(pos)
+	local meta=minetest.get_meta(pos)
+	if not meta:contains("magnetizerPosition") then
+		return
+	end
+	local magnetizerPosition=minetest.deserialize(meta:get_string("magnetizerPosition"))
+	industrialtest.Magnetizer.detachFenceRail(magnetizerPosition)
+end
+
+-- \brief Function which should be called after iron fence was removed
+-- \param meta table
+-- \returns nil
+local function ironFenceDetach(meta)
+	if not meta or not meta.fields or not meta.fields.magnetizerPosition then
+		return
+	end
+	local magnetizerPosition=minetest.deserialize(meta.fields.magnetizerPosition)
+	industrialtest.Magnetizer:determineFenceRail(magnetizerPosition)
+	industrialtest.Magnetizer:determinePowerCapacity(magnetizerPosition)
+	industrialtest.Magnetizer:updateFormspec(magnetizerPosition)
+end
+
+if industrialtest.mtgAvailable then
+	local inventoryImage="default_fence_overlay.png^default_steel_block.png^default_fence_overlay.png^[makealpha:255,126,126"
+	default.register_fence("industrialtest:iron_fence",{
+		description=S("Iron Fence"),
+		texture="default_steel_block.png",
+		inventory_image=inventoryImage,
+		wield_image=inventoryImage,
+		groups={
+			cracky=1,
+			level=2,
+			_industrialtest_metalFence=1
+		},
+		sounds=default.node_sound_metal_defaults(),
+		connects_to={
+			"group:fence",
+			"group:wood",
+			"group:tree",
+			"group:wall",
+			"industrialtest:magnetizer"
+		},
+		on_construct=ironFenceOnConstruct,
+		on_destruct=ironFenceOnDestruct,
+		after_dig_node=function(pos,oldnode,oldmeta)
+			ironFenceDetach(oldmeta)
+		end
+	})
+	minetest.register_craft({
+		type="shaped",
+		output="industrialtest:iron_fence 4",
+		recipe={
+			{"industrialtest:iron_plate","industrialtest:iron_plate","industrialtest:iron_plate"},
+			{"industrialtest:iron_plate","industrialtest:iron_plate","industrialtest:iron_plate"}
+		}
+	})
+elseif industrialtest.mclAvailable then
+	-- Some MCL2 forks define this function so use it if available
+	if mcl_fences.register_fence_def then
+		mcl_fences.register_fence_def("iron_fence",{
+			description=S("Iron Fence"),
+			tiles={"default_steel_block.png"},
+			groups={
+				_industrialtest_metalFence=1
+			},
+			connects_to={
+				"group:fence",
+				"group:fence_gate",
+				"group:solid",
+				"industrialtest:magnetizer"
+			},
+			on_construct=ironFenceOnConstruct,
+			on_destruct=ironFenceOnDestruct,
+			after_destruct=function(pos,oldnode,oldmeta)
+				ironFenceDetach(oldmeta)
+			end
+		})
+	else
+		mcl_fences.register_fence("iron_fence",S("Iron Fence"),"default_steel_block.png",{_industrialtest_metalFence=1},4,5,{"industrialtest:magnetizer","group:fence"},mcl_sounds.node_sound_metal_defaults())
+	end
+	if minetest.registered_nodes["mcl_fences:iron_fence"] then
+		-- mcl_fences.register_fence_def registers fences in it's own namespace so register alias here to keep compatibility
+		minetest.register_alias("industrialtest:iron_fence","mcl_fences:iron_fence")
+	end
+	minetest.register_craft({
+		type="shaped",
+		output="industrialtest:iron_fence 3",
+		recipe={
+			{"industrialtest:iron_plate","industrialtest:iron_plate","industrialtest:iron_plate"},
+			{"industrialtest:iron_plate","industrialtest:iron_plate","industrialtest:iron_plate"}
+		}
+	})
+end

settingtypes.txt

@@ -0,0 +1,8 @@
+# This determines value how frequently machines update
+industrialtest.updateDelay (Update delay) float 1.0
+
+# Whether electrocution by uninsulated cables is used
+industrialtest.electrocution (Electrocution) bool true
+
+# Enables additional utils useful when developing mod
+industrialtest.developerMode (Developer mode) bool false

textures/SOURCES.md

@@ -3,4 +3,4 @@
 - `industrialtest_gui_water.png` was taken from Minetest Game (by Cisoun licensed with CC BY-SA 3.0)
 - `industrialtest_gui_river_water.png` was taken from Minetest Game (by paramat licensed with CC BY-SA 3.0)
 
-... rest was made either by LuanHawk, mrkubax10 or Migdyn and is licensed with CC BY 4.0 International
+... rest was made either by LuanHawk, mrkubax10, HandfulOfFrogs or Migdyn and is licensed with CC BY 4.0 International

tools/activated_electric_tool.lua

@@ -0,0 +1,160 @@
+-- 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.ActivatedElectricTool=table.copy(industrialtest.ElectricTool)
+
+function industrialtest.ActivatedElectricTool.createDefinitionTable(self)
+	local def=industrialtest.ElectricTool.createDefinitionTable(self)
+
+	def.groups._industrialtest_activatedElectricTool=1
+	def.tool_capabilities.full_punch_interval=self.fullPunchInterval
+	if self.digs then
+		self:defineToolCapabilities(def,nil,self.digSpeed)
+	end
+	if self.hits then
+		def.tool_capabilities.damage_groups={}
+		for _,hitType in ipairs(self.hits) do
+			def.tool_capabilities.damage_groups[hitType]=1
+		end
+	end
+
+	return def
+end
+
+function industrialtest.ActivatedElectricTool.createActiveDefinitionTable(self)
+	local def=self:createDefinitionTable()
+
+	if self.digs or self.hits then
+		self:defineToolCapabilities(def,self.active.times,self.active.digSpeed)
+	end
+
+	def.groups.not_in_creative_inventory=1
+
+	def.after_use=function(itemstack,user,node,digparams)
+		if self:afterUse(itemstack,user,node,digparams) then
+			return itemstack
+		end
+		return nil
+	end
+
+	return def
+end
+
+function industrialtest.ActivatedElectricTool.register(self)
+	industrialtest.ElectricTool.register(self)
+	local def=self:createActiveDefinitionTable()
+	minetest.register_tool(self.name.."_active",def)
+end
+
+function industrialtest.ActivatedElectricTool.beforeUse(self,itemstack,node)
+	local def=itemstack:get_definition()
+	if self:canActivate(itemstack,node) then
+		if not self.isActive(itemstack) then
+			itemstack:set_name(itemstack:get_name().."_active")
+		end
+		return true
+	else
+		itemstack:set_name(self.name)
+	end
+	return false
+end
+
+function industrialtest.ActivatedElectricTool.afterUse(self,itemstack,user,node,digparams)
+	local meta=itemstack:get_meta()
+	industrialtest.api.addPowerToItem(itemstack,-self:getOpPower(itemstack))
+	return true
+end
+
+function industrialtest.ActivatedElectricTool.canActivate(self,itemstack,node)
+	local meta=itemstack:get_meta()
+	return meta:get_int("industrialtest.powerAmount")>=self:getOpPower(itemstack)
+end
+
+function industrialtest.ActivatedElectricTool.isActive(itemstack)
+	return string.sub(itemstack:get_name(),-string.len("_active"),-1)=="_active"
+end
+
+function industrialtest.ActivatedElectricTool.defineToolCapabilities(self,def,times,digSpeed)
+	if industrialtest.mtgAvailable then
+		if self.digs then
+			def.tool_capabilities.groupcaps={}
+			for _,digType in ipairs(self.digs) do
+				def.tool_capabilities.groupcaps[digType]={
+					times=times,
+					maxlevel=self.digLevel+1
+				}
+				if digType=="choppy" then
+					def.groups.axe=1
+				elseif digType=="cracky" then
+					def.groups.pickaxe=1
+				elseif digType=="crumbly" then
+					def.groups.shovel=1
+				elseif digType=="hoey" then
+					def.groups.hoe=1
+				end
+			end
+		end
+		if self.hits then
+			for _,hitType in ipairs(self.hits) do
+				if hitType=="fleshy" then
+					def.groups.sword=1
+				end
+			end
+		end
+	elseif industrialtest.mclAvailable then
+		if self.digs then
+			local digTypeMapping={
+				choppy={"axey"},
+				cracky={"pickaxey"},
+				crumbly={"shovely"},
+				hoey={"hoey"},
+				snappy={"swordy","swordy_cobweb"}
+			}
+			def.groups.dig_speed_class=self.digSpeedClass
+			def._mcl_diggroups={}
+			for _,digType in ipairs(self.digs) do
+				for _,mappedDigType in ipairs(digTypeMapping[digType]) do
+					def._mcl_diggroups[mappedDigType]={
+						speed=digSpeed,
+						level=5-self.digLevel,
+						uses=-1
+					}
+				end
+			end
+		end
+		if self.hits then
+			for _,hitType in ipairs(self.hits) do
+				if hitType=="fleshy" then
+					def.groups.weapon=1
+					def.groups.sword=1
+				end
+			end
+		end
+	end
+end
+
+minetest.register_on_punchnode(function(pos,node,user)
+	if not user then
+		return
+	end
+
+	local itemstack=user:get_wielded_item()
+	local def=itemstack:get_definition()
+	if def and def._industrialtest_self and def.groups and def.groups._industrialtest_activatedElectricTool and
+		def._industrialtest_self:beforeUse(itemstack,node) then
+		user:set_wielded_item(itemstack)
+	end
+end)

tools/batpack.lua

@@ -15,72 +15,44 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
+industrialtest.BatPackBase=table.copy(industrialtest.ElectricGearTool)
+industrialtest.internal.unpackTableInto(industrialtest.BatPackBase,{
+	part="torso"
+})
 
 local updateDelta=0
-
-local function registerBatpack(config)
-	if industrialtest.mtgAvailable then
-		armor:register_armor("industrialtest:"..config.name,{
-			description=config.displayName,
-			inventory_image="industrialtest_"..config.name.."_inv.png",
-			groups={
-				armor_torso=1,
-				armor_heal=0,
-				_industrialtest_batpack=1
-			},
-			_industrialtest_powerStorage=true,
-			_industrialtest_powerCapacity=config.powerCapacity,
-			_industrialtest_powerFlow=config.powerFlow
-		})
-	elseif industrialtest.mclAvailable then
-		minetest.register_tool("industrialtest:"..config.name,{
-			description=config.displayName,
-			inventory_image="industrialtest_"..config.name.."_inv.png",
-			groups={
-				armor=1,
-				non_combat_armor=1,
-				armor_torso=1,
-				non_combat_torso=1,
-				_industrialtest_batpack=1
-			},
-			sounds={
-				_mcl_armor_equip="mcl_armor_equip_iron",
-				_mcl_armor_unequip="mcl_armor_unequip_iron"
-			},
-			on_place=mcl_armor.equip_on_use,
-			on_secondary_use=mcl_armor.equip_on_use,
-			_mcl_armor_element="torso",
-			_mcl_armor_texture="industrialtest_"..config.name..".png",
-			_industrialtest_powerStorage=true,
-			_industrialtest_powerCapacity=config.powerCapacity,
-			_industrialtest_powerFlow=config.powerFlow
-		})
-	end
-end
-
-local function onGlobalStep(player,inv,stack,index,def)
-	if not def.groups or not def.groups._industrialtest_batpack then
+function industrialtest.BatPackBase.update(self,player,inv,itemstack,dtime)
+	updateDelta=updateDelta+dtime
+	if updateDelta<industrialtest.config.updateDelay then
 		return false
 	end
+	updateDelta=0
+
 	local wielded=player:get_wielded_item()
 	local wieldedMeta=wielded:get_meta()
-	if not industrialtest.api.hasPowerStorage(wieldedMeta) or wieldedMeta:get_int("industrialtest.powerFlow")>def._industrialtest_powerFlow then
-		return true
+	if not industrialtest.api.hasPowerStorage(wieldedMeta) or wieldedMeta:get_int("industrialtest.powerFlow")>self.flow then
+		return false
 	end
-	if industrialtest.api.transferPowerFromItem(stack,wieldedMeta,def._industrialtest_powerFlow)>0 then
+	if industrialtest.api.transferPowerFromItem(itemstack,wieldedMeta,self.flow)>0 then
 		industrialtest.api.updateItemPowerText(wielded)
 		player:set_wielded_item(wielded)
-		inv:set_stack("armor",index,stack)
-	end
 		return true
+	end
+	return false
 end
 
-registerBatpack({
-	name="batpack_v",
-	displayName=S("BatPack"),
-	powerCapacity=60000,
-	powerFlow=industrialtest.api.lvPowerFlow
+industrialtest.BatPack=table.copy(industrialtest.BatPackBase)
+industrialtest.internal.unpackTableInto(industrialtest.BatPack,{
+	name="industrialtest:batpack_v",
+	description=S("BatPack"),
+	inventoryImage="industrialtest_batpack_v_inv.png",
+	modelImage="industrialtest_batpack_v.png",
+	capacity=60000,
+	flow=industrialtest.api.lvPowerFlow
 })
+
+industrialtest.BatPack:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:batpack_v",
@@ -91,48 +63,24 @@ minetest.register_craft({
 	}
 })
 
-registerBatpack({
-	name="lappack_v",
-	displayName=S("LapPack"),
-	powerCapacity=300000,
-	powerFlow=industrialtest.api.hvPowerFlow
+industrialtest.LapPack=table.copy(industrialtest.BatPackBase)
+industrialtest.internal.unpackTableInto(industrialtest.LapPack,{
+	name="industrialtest:lappack_v",
+	description=S("LapPack"),
+	inventoryImage="industrialtest_lappack_v_inv.png",
+	modelImage="industrialtest_lappack_v.png",
+	capacity=300000,
+	flow=industrialtest.api.mvPowerFlow
 })
+
+industrialtest.LapPack:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:lappack_v",
 	recipe={
-		{industrialtest.elementKeys.powerCarrier,"industrialtest:electronic_circuit",industrialtest.elementKeys.powerCarrier},
+		{industrialtest.elementKeys.powerCarrier,"industrialtest:advanced_electronic_circuit",industrialtest.elementKeys.powerCarrier},
 		{industrialtest.elementKeys.powerCarrier,"industrialtest:batpack_v",industrialtest.elementKeys.powerCarrier},
 		{industrialtest.elementKeys.powerCarrier,"",industrialtest.elementKeys.powerCarrier}
 	}
 })
-
-minetest.register_globalstep(function(dtime)
-	updateDelta=updateDelta+dtime
-	if updateDelta<industrialtest.updateDelay then
-		return
-	end
-	updateDelta=0
-	local players=minetest.get_connected_players()
-	for _,player in ipairs(players) do
-		if industrialtest.mtgAvailable then
-			local _,inv=armor:get_valid_player(player,"")
-			if inv then
-				local armorList=inv:get_list("armor")
-				assert(armorList)
-				for i=1,#armorList do
-					local stack=armorList[i]
-					local def=stack:get_definition()
-					if onGlobalStep(player,inv,stack,i,def) then
-						break
-					end
-				end
-			end
-		elseif industrialtest.mclAvailable then
-			local inv=player:get_inventory()
-			local stack=inv:get_stack("armor",3)
-			local def=stack:get_definition()
-			onGlobalStep(player,inv,stack,3,def)
-		end
-	end
-end)

tools/common.lua

@@ -19,23 +19,6 @@ industrialtest.internal.registeredElectricDrills={}
 industrialtest.internal.registeredElectricHoes={}
 industrialtest.internal.registeredElectricSabers={}
 
-local function isActive(itemstack)
-	return string.sub(itemstack:get_name(),-string.len("_active"),-1)=="_active"
-end
-
-local function beforeUse(user,itemstack,canDig)
-	local meta=itemstack:get_meta()
-	local def=itemstack:get_definition()
-	if meta:get_int("industrialtest.powerAmount")>=20 and canDig then
-		if not isActive(itemstack) then
-			itemstack:set_name(itemstack:get_name().."_active")
-		end
-	else
-		itemstack:set_name(def._industrialtest_inactiveName)
-	end
-	user:set_wielded_item(itemstack)
-end
-
 minetest.register_on_punchnode(function(pos,node,user,pointed)
 	if not user then
 		return

tools/electric_armor.lua

@@ -0,0 +1,115 @@
+-- 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.ElectricArmor={
+	prepare=industrialtest.ElectricItem.prepare
+}
+
+function industrialtest.ElectricArmor.createDefinitionTableForElement(self,element)
+	local def={
+		description=element.description,
+		inventory_image=element.inventoryImage,
+		groups={
+			_industrialtest_electricArmor=1,
+			["armor_"..element.element]=1
+		},
+		_industrialtest_self=self
+	}
+
+	if industrialtest.mclAvailable then
+		def.groups.armor=1
+		def.groups.non_combat_armor=1
+		def.sounds={
+			_mcl_armor_equip="mcl_armor_equip_iron",
+			_mcl_armor_unequip="mcl_armor_unequip_iron"
+		}
+		def.on_place=mcl_armor.armor_on_use
+		def.on_secondary_use=mcl_armor.armor_on_use
+		def._mcl_armor_element=element.element
+		if type(element.texture)=="string" then
+			def._mcl_armor_texture=element.texture
+		else
+			def._mcl_armor_texture=element.texture[2] or element.texture[1]
+		end
+	end
+
+	return def
+end
+
+function industrialtest.ElectricArmor.register(self)
+	for _,element in ipairs(self.elements) do
+		local def=self:createDefinitionTableForElement(element)
+		local name=self.name.."_"..element.name
+		if industrialtest.mtgAvailable then
+			armor:register_armor(name,def)
+		elseif industrialtest.mclAvailable then
+			minetest.register_tool(name,def)
+		end
+	end
+end
+
+function industrialtest.ElectricArmor.tryReduceDamage(self,itemstack,hpChange)
+	local meta=itemstack:get_meta()
+	local targetReducedDamage=math.floor(math.abs(hpChange)*self:getReducedDamageForItem(itemstack))
+	local powerPerDamage=self:getPowerPerDamageForItem(itemstack)
+	local requiredPower=targetReducedDamage*powerPerDamage
+	local availablePower=math.min(meta:get_int("industrialtest.powerAmount"),requiredPower)
+	return math.floor(availablePower/powerPerDamage)
+end
+
+function industrialtest.ElectricArmor.getReducedDamageForItem(self,itemstack)
+	-- dummy function
+	return 0
+end
+
+function industrialtest.ElectricArmor.getPowerPerDamageForItem(self,itemstack)
+	-- dummy function
+	return 0
+end
+
+minetest.register_on_player_hpchange(function(player,hpChange)
+	if hpChange>0 or not player:is_player() then
+		return hpChange
+	end
+
+	local inv
+	if industrialtest.mtgAvailable then
+		_,inv=armor:get_valid_player(player,"")
+		if not inv then
+			return hpChange
+		end
+	elseif industrialtest.mclAvailable then
+		inv=player:get_inventory()
+	end
+
+	local armorList=inv:get_list("armor")
+	assert(armorList)
+	local result=hpChange
+	for i=1,#armorList do
+		local itemstack=armorList[i]
+		local def=itemstack:get_definition()
+		if def.groups and def.groups._industrialtest_electricArmor and def._industrialtest_self then
+			local reducedDamage=def._industrialtest_self:tryReduceDamage(itemstack,hpChange)
+			if reducedDamage>0 then
+				result=result+reducedDamage
+				industrialtest.api.addPowerToItem(itemstack,-reducedDamage*def._industrialtest_self:getPowerPerDamageForItem(itemstack))
+				inv:set_stack("armor",i,itemstack)
+			end
+		end
+	end
+
+	return result
+end,true)

tools/electric_chainsaw.lua

@@ -15,107 +15,42 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
+industrialtest.ElectricChainsawBase=table.copy(industrialtest.ActivatedElectricTool)
+industrialtest.internal.unpackTableInto(industrialtest.ElectricChainsawBase,{
+	digs={"choppy"}
+})
 
-local electricChainsaw={}
-
-electricChainsaw.afterUse=function(itemstack,config)
-	local meta=itemstack:get_meta()
-	industrialtest.api.addPowerToItem(itemstack,-20)
-	if meta:get_int("industrialtest.powerAmount")<20 then
-		itemstack:set_name("industrialtest:"..config.name)
+function industrialtest.ElectricChainsawBase.use(self,itemstack,user,pointed)
+	if not industrialtest.mclAvailable then
+		return false
 	end
-	return itemstack
-end
-
-local function registerElectricChainsaw(config)
-	local definition={
-		description=config.displayName,
-		inventory_image="industrialtest_"..config.name..".png",
-		after_use=function(itemstack)
-			-- Hack to make sure that chainsaw won't be destroyed when has 0 EU
-			return nil
-		end,
-		_industrialtest_powerStorage=true,
-		_industrialtest_powerCapacity=10000,
-		_industrialtest_powerFlow=industrialtest.api.lvPowerFlow,
-		_industrialtest_inactiveName="industrialtest:"..config.name
-	}
-	if industrialtest.mtgAvailable then
-		definition.tool_capabilities={
-			full_punch_interval=0.5,
-			max_drop_level=config.maxDropLevel,
-			groupcaps={
-				choppy={
-					times=config.inactiveTimes,
-					maxlevel=config.maxLevel
-				}
-			}
-		}
-		definition.groups={
-			axe=1
-		}
-	elseif industrialtest.mclAvailable then
-		definition.tool_capabilities={
-			full_punch_interval=0.5,
-			max_drop_level=config.maxDropLevel,
-		}
-		definition.groups={
-			tool=1,
-			dig_speed_class=config.digSpeedClass,
-		}
-		definition.on_place=function(itemstack,user,pointed)
 	local meta=itemstack:get_meta()
-			if meta:get_int("industrialtest.powerAmount")>=20 then
 	local itemstackCopy=itemstack
-				if itemstack:get_wear()~=industrialtest.internal.mclMakeStrippedTrunk(itemstackCopy,user,pointed,true):get_wear() then
-					industrialtest.api.addPowerToItem(itemstack,-20)
-					return itemstack
-				end
-			end
-			return nil
-		end
-		definition._mcl_diggroups={
-			axey={
-				speed=config.inactiveDigSpeed,
-				level=config.digLevel,
-				uses=-1
-			}
-		}
-		definition._mcl_toollike_wield=true
-	end
-	minetest.register_tool("industrialtest:"..config.name,definition)
-	definition=table.copy(definition)
-	if industrialtest.mtgAvailable then
-		definition.tool_capabilities.groupcaps.choppy.times=config.activeTimes
-	elseif industrialtest.mclAvailable then
-		definition._mcl_diggroups.axey.speed=config.activeDigSpeed
-	end
-	definition.groups.not_in_creative_inventory=1
-	definition.on_use=nil
-	definition.after_use=function(itemstack)
-		return electricChainsaw.afterUse(itemstack,config)
-	end
-	minetest.register_tool("industrialtest:"..config.name.."_active",definition)
-	industrialtest.internal.registeredElectricChainsaws["industrialtest:"..config.name]=true
-	industrialtest.internal.registeredElectricChainsaws["industrialtest:"..config.name.."_active"]=true
+	return itemstack:get_wear()~=industrialtest.internal.mclMakeStrippedTrunk(itemstackCopy,user,pointed,true):get_wear()
 end
-local definition={
-	name="electric_chainsaw",
-	displayName=S("Electric Chainsaw")
-}
-if industrialtest.mtgAvailable then
-	definition.maxDropLevel=1
-	definition.inactiveTimes={[1]=10,[2]=5.6,[3]=4}
-	definition.maxLevel=2
-	definition.activeTimes={[1]=2.2,[2]=1.1,[3]=0.7}
-elseif industrialtest.mclAvailable then
-	definition.digSpeedClass=4
-	definition.maxDropLevel=4
-	definition.inactiveDigSpeed=1
-	definition.digLevel=4
-	definition.activeDigSpeed=7
+
+function industrialtest.ElectricChainsawBase.getOpPower(self,itemstack)
+	return 50
 end
-registerElectricChainsaw(definition)
+
+industrialtest.ElectricChainsaw=table.copy(industrialtest.ElectricChainsawBase)
+industrialtest.internal.unpackTableInto(industrialtest.ElectricChainsaw,{
+	name="industrialtest:electric_chainsaw",
+	description=S("Electric Chainsaw"),
+	inventoryImage="industrialtest_electric_chainsaw.png",
+	capacity=10000,
+	flow=industrialtest.api.lvPowerFlow,
+	digLevel=0,
+	digSpeedClass=4,
+	digSpeed=1,
+	active={
+		times={[1]=1.7,[2]=1.2,[3]=1.0,[4]=0.7},
+		digSpeed=7
+	}
+})
+
+industrialtest.ElectricChainsaw:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:electric_chainsaw",
@@ -125,26 +60,28 @@ minetest.register_craft({
 		{"industrialtest:re_battery","industrialtest:refined_iron_ingot",""}
 	}
 })
-definition={
-	name="diamond_electric_chainsaw",
-	displayName=S("Diamond Electric Chainsaw")
-}
-if industrialtest.mtgAvailable then
-	definition.maxDropLevel=1
-	definition.inactiveTimes={[1]=10,[2]=5.6,[3]=4}
-	definition.maxLevel=3
-	definition.activeTimes={[1]=2.0,[2]=0.8,[3]=0.4}
-elseif industrialtest.mclAvailable then
-	definition.digSpeedClass=5
-	definition.maxDropLevel=5
-	definition.inactiveDigSpeed=1
-	definition.digLevel=5
-	definition.activeDigSpeed=9
-end
-registerElectricChainsaw(definition)
+
+industrialtest.AdvancedElectricChainsaw=table.copy(industrialtest.ElectricChainsawBase)
+industrialtest.internal.unpackTableInto(industrialtest.AdvancedElectricChainsaw,{
+	name="industrialtest:advanced_electric_chainsaw",
+	description=S("Advanced Electric Chainsaw"),
+	inventoryImage="industrialtest_advanced_electric_chainsaw.png",
+	capacity=10000,
+	flow=industrialtest.api.lvPowerFlow,
+	digLevel=0,
+	digSpeedClass=5,
+	digSpeed=1,
+	active={
+		times={[1]=1.0,[2]=0.7,[3]=0.5,[4]=0.2},
+		digSpeed=8
+	}
+})
+
+industrialtest.AdvancedElectricChainsaw:register()
+
 minetest.register_craft({
 	type="shaped",
-	output="industrialtest:diamond_electric_chainsaw",
+	output="industrialtest:advanced_electric_chainsaw",
 	recipe={
 		{"",industrialtest.elementKeys.diamond,""},
 		{industrialtest.elementKeys.diamond,"industrialtest:electric_chainsaw",industrialtest.elementKeys.diamond}

tools/electric_drill.lua

@@ -15,107 +15,41 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
+industrialtest.ElectricDrillBase=table.copy(industrialtest.ActivatedElectricTool)
+industrialtest.internal.unpackTableInto(industrialtest.ElectricDrillBase,{
+	digs={
+		"cracky",
+		"crumbly"
+	}
+})
 
-local electricDrill={}
-
-electricDrill.afterUse=function(itemstack,config)
-	local meta=itemstack:get_meta()
-	industrialtest.api.addPowerToItem(itemstack,-20)
-	if meta:get_int("industrialtest.powerAmount")<20 then
-		itemstack:set_name("industrialtest:"..config.name)
-	end
-	return itemstack
+function industrialtest.ElectricDrillBase.createDefinitionTable(self)
+	local def=industrialtest.ActivatedElectricTool.createDefinitionTable(self)
+	def.groups._industrialtest_miningDrill=1
+	return def
 end
 
-local function registerElectricDrill(config)
-	local definition={
-		description=config.displayName,
-		inventory_image="industrialtest_"..config.name..".png",
-		after_use=function()
-			-- Hack to make sure that drill won't be destroyed when has 0 EU
-			return nil
-		end,
-		_industrialtest_powerStorage=true,
-		_industrialtest_powerCapacity=10000,
-		_industrialtest_powerFlow=industrialtest.api.lvPowerFlow,
-		_industrialtest_inactiveName="industrialtest:"..config.name
-	}
-	if industrialtest.mtgAvailable then
-		definition.tool_capabilities={
-			full_punch_interval=0.5,
-			max_drop_level=config.maxDropLevel,
-			groupcaps={
-				cracky={
-					times=config.inactiveTimes,
-					maxlevel=config.maxLevel
-				},
-				crumbly={
-					times=config.inactiveTimes,
-					maxlevel=config.maxLevel
-				}
-			}
-		}
-		definition.groups={
-			pickaxe=1,
-			shovel=1
-		}
-	elseif industrialtest.mclAvailable then
-		definition.tool_capabilities={
-			full_punch_interval=0.5,
-			max_drop_level=config.maxDropLevel
-		}
-		definition.groups={
-			tool=1,
-			dig_speed_class=config.digSpeedClass
-		}
-		definition._mcl_diggroups={
-			pickaxey={
-				speed=config.inactiveDigSpeed,
-				level=config.digLevel,
-				uses=-1
-			},
-			shovely={
-				speed=config.inactiveDigSpeed,
-				level=config.digLevel,
-				uses=-1
-			}
-		}
-		definition._mcl_toollike_wield=true
-	end
-	minetest.register_tool("industrialtest:"..config.name,definition)
-	definition=table.copy(definition)
-	if industrialtest.mtgAvailable then
-		definition.tool_capabilities.groupcaps.cracky.times=config.activeTimes
-		definition.tool_capabilities.groupcaps.crumbly.times=config.activeTimes
-	elseif industrialtest.mclAvailable then
-		definition._mcl_diggroups.pickaxey.speed=config.activeDigSpeed
-		definition._mcl_diggroups.shovely.speed=config.activeDigSpeed
-	end
-	definition.groups.not_in_creative_inventory=1
-	definition.after_use=function(itemstack)
-		return electricDrill.afterUse(itemstack,config)
-	end
-	minetest.register_tool("industrialtest:"..config.name.."_active",definition)
-	industrialtest.internal.registeredElectricDrills["industrialtest:"..config.name]=true
-	industrialtest.internal.registeredElectricDrills["industrialtest:"..config.name.."_active"]=true
+function industrialtest.ElectricDrillBase.getOpPower(self,itemstack)
+	return 50
 end
-local definition={
-	name="electric_drill",
-	displayName=S("Electric Drill")
-}
-if industrialtest.mtgAvailable then
-	definition.maxDropLevel=1
-	definition.inactiveTimes={[1]=10,[2]=5.6,[3]=4}
-	definition.maxLevel=2
-	definition.activeTimes={[1]=2.0,[2]=0.8,[3]=0.4}
-elseif industrialtest.mclAvailable then
-	definition.digSpeedClass=4
-	definition.maxDropLevel=4
-	definition.inactiveDigSpeed=1
-	definition.digLevel=4
-	definition.activeDigSpeed=7
-end
-registerElectricDrill(definition)
+
+industrialtest.ElectricDrill=table.copy(industrialtest.ElectricDrillBase)
+industrialtest.internal.unpackTableInto(industrialtest.ElectricDrill,{
+	name="industrialtest:electric_drill",
+	description=S("Electric Drill"),
+	inventoryImage="industrialtest_electric_drill.png",
+	capacity=30000,
+	flow=industrialtest.api.lvPowerFlow,
+	digLevel=1,
+	digSpeedClass=4,
+	active={
+		times={[1]=1.7,[2]=1.2,[3]=1.0,[4]=0.7},
+		digSpeed=4
+	}
+})
+
+industrialtest.ElectricDrill:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:electric_drill",
@@ -125,26 +59,27 @@ minetest.register_craft({
 		{"industrialtest:refined_iron_ingot","industrialtest:re_battery","industrialtest:refined_iron_ingot"}
 	}
 })
-definition={
-	name="diamond_electric_drill",
-	displayName=S("Diamond Electric Drill")
-}
-if industrialtest.mtgAvailable then
-	definition.maxDropLevel=1
-	definition.inactiveTimes={[1]=10,[2]=5.6,[3]=4}
-	definition.maxLevel=3
-	definition.activeTimes={[1]=2.0,[2]=0.8,[3]=0.4}
-elseif industrialtest.mclAvailable then
-	definition.digSpeedClass=5
-	definition.maxDropLevel=5
-	definition.inactiveDigSpeed=1
-	definition.digLevel=5
-	definition.activeDigSpeed=9
-end
-registerElectricDrill(definition)
+
+industrialtest.AdvancedElectricDrill=table.copy(industrialtest.ElectricDrillBase)
+industrialtest.internal.unpackTableInto(industrialtest.AdvancedElectricDrill,{
+	name="industrialtest:advanced_electric_drill",
+	description=S("Advanced Electric Drill"),
+	inventoryImage="industrialtest_advanced_electric_drill.png",
+	capacity=30000,
+	flow=industrialtest.api.lvPowerFlow,
+	digLevel=0,
+	digSpeedClass=5,
+	active={
+		times={[1]=1.0,[2]=0.7,[3]=0.3,[4]=0.1},
+		digSpeed=7
+	}
+})
+
+industrialtest.AdvancedElectricDrill:register()
+
 minetest.register_craft({
 	type="shaped",
-	output="industrialtest:diamond_electric_drill",
+	output="industrialtest:advanced_electric_drill",
 	recipe={
 		{"",industrialtest.elementKeys.diamond,""},
 		{industrialtest.elementKeys.diamond,"industrialtest:electric_drill",industrialtest.elementKeys.diamond}

tools/electric_gear_tool.lua

@@ -0,0 +1,20 @@
+-- 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.ElectricGearTool=table.copy(industrialtest.GearTool)
+industrialtest.internal.unpackTableInto(industrialtest.ElectricGearTool,{
+	prepare=industrialtest.ElectricItem.prepare
+})

tools/electric_hoe.lua

@@ -15,30 +15,25 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
+industrialtest.ElectricHoeBase=table.copy(industrialtest.ActivatedElectricTool)
+industrialtest.internal.unpackTableInto(industrialtest.ElectricHoeBase,{
+	digs={"hoey"},
+	capacity=10000,
+	flow=industrialtest.api.lvPowerFlow
+})
 
-local electricHoe={}
-
-electricHoe.afterUse=function(itemstack,config)
-	local meta=itemstack:get_meta()
-	industrialtest.api.addPowerToItem(itemstack,-20)
-	if meta:get_int("industrialtest.powerAmount")<20 then
-		itemstack:set_name("industrialtest:"..config.name)
+function industrialtest.ElectricHoeBase.register(self)
+	if industrialtest.mtgAvailable then
+		self.define.onUse=true
+	elseif industrialtest.mclAvailable then
+		self.define.onPlace=true
 	end
-	return itemstack
+
+	industrialtest.ActivatedElectricTool.register(self)
 end
 
-local function registerElectricHoe(config)
-	local definition={
-		description=config.displayName,
-		inventory_image="industrialtest_"..config.name..".png",
-		_industrialtest_powerStorage=true,
-		_industrialtest_powerCapacity=10000,
-		_industrialtest_powerFlow=industrialtest.api.lvPowerFlow,
-		_industrialtest_inactiveName="industrialtest:"..config.name
-	}
-	if industrialtest.mtgAvailable then
+function industrialtest.ElectricHoeBase.hitUse(self,itemstack,user,pointed)
 	-- Taken and adapted from farming mod from Minetest Game
-		local function onUse(user,pointed)
 	local pt = pointed
 	-- check if pointing at a node
 	if not pt then
@@ -95,104 +90,60 @@ local function registerElectricHoe(config)
 	}, true)
 
 	return true
-		end
-		definition.groups={
-			hoe=1
-		}
-		definition.on_use=function(itemstack,user,pointed)
-			local meta=itemstack:get_meta()
-			if meta:get_int("industrialtest.powerAmount")>=20 and onUse(user,pointed) then
-				industrialtest.api.addPowerToItem(itemstack,-20)
-				return itemstack
-			end
-			return nil
-		end
-	elseif industrialtest.mclAvailable then
-		-- Taken from https://git.minetest.land/MineClone2/MineClone2/src/branch/master/mods/ITEMS/mcl_farming/hoes.lua#L3
-		local function createSoil(pos)
-			if pos == nil then
+end
+
+function industrialtest.ElectricHoeBase.use(self,itemstack,user,pointed)
+	local node=minetest.get_node(pointed.under)
+	if user and not user:get_player_control().sneak then
+		if minetest.registered_nodes[node.name] and minetest.registered_nodes[node.name].on_rightclick then
+			minetest.registered_nodes[node.name].on_rightclick(pointed.under,node,user,itemstack)
 			return false
 		end
-			local node = minetest.get_node(pos)
+	end
+	if minetest.is_protected(pointed.under, user:get_player_name()) then
+		minetest.record_protection_violation(pointed.under,user:get_player_name())
+		return false
+	end
+
+	-- Taken and adapted from https://git.minetest.land/MineClone2/MineClone2/src/branch/master/mods/ITEMS/mcl_farming/hoes.lua#L3
 	local name = node.name
-			local above = minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z})
+	local above = minetest.get_node({x=pointed.under.x, y=pointed.under.y+1, z=pointed.under.z})
 	if minetest.get_item_group(name, "cultivatable") == 2 then
 		if above.name == "air" then
 			node.name = "mcl_farming:soil"
-					minetest.set_node(pos, node)
-					minetest.sound_play("default_dig_crumbly", { pos = pos, gain = 0.5 }, true)
+			minetest.set_node(pointed.under, node)
+			minetest.sound_play("default_dig_crumbly", { pos = pointed.under, gain = 0.5 }, true)
 			return true
 		end
 	elseif minetest.get_item_group(name, "cultivatable") == 1 then
 		if above.name == "air" then
 			node.name = "mcl_core:dirt"
-					minetest.set_node(pos, node)
-					minetest.sound_play("default_dig_crumbly", { pos = pos, gain = 0.6 }, true)
+			minetest.set_node(pointed.under, node)
+			minetest.sound_play("default_dig_crumbly", { pos = pointed.under, gain = 0.6 }, true)
 			return true
 		end
 	end
 	return false
-		end
-		definition.tool_capabilities={
-			full_punch_interval=0.5
-		}
-		definition.groups={
-			tool=1
-		}
-		definition.on_place=function(itemstack,user,pointed)
-			local node=minetest.get_node(pointed.under)
-			if user and not user:get_player_control().sneak then
-				if minetest.registered_nodes[node.name] and minetest.registered_nodes[node.name].on_rightclick then
-					return minetest.registered_nodes[node.name].on_rightclick(pointed.under,node,user,itemstack) or itemstack
-				end
-			end
-			if minetest.is_protected(pointed.under, user:get_player_name()) then
-				minetest.record_protection_violation(pointed.under,user:get_player_name())
-				return nil
-			end
-			local meta=itemstack:get_meta()
-			if meta:get_int("industrialtest.powerAmount")>=20 and createSoil(pointed.under) then
-				industrialtest.api.addPowerToItem(itemstack,-20)
-				return itemstack
-			end
-			return nil
-		end
-		definition.after_use=function(itemstack)
-			-- Hack to make sure that chainsaw won't be destroyed when has 0 EU in MCL
-			return nil
-		end
-		definition._mcl_toollike_wield=true
-		definition._mcl_diggroups={
-			hoey={
-				speed=config.inactiveDigSpeed,
-				level=config.digLevel,
-				uses=-1
-			}
-		}
-	end
-	minetest.register_tool("industrialtest:"..config.name,definition)
-	if industrialtest.mclAvailable then
-		definition=table.copy(definition)
-		definition._mcl_diggroups.hoey.speed=config.activeDigSpeed
-		definition.groups.not_in_creative_inventory=1
-		definition.after_use=function(itemstack)
-			return electricHoe.afterUse(itemstack,config)
-		end
-		minetest.register_tool("industrialtest:"..config.name.."_active",definition)
-		industrialtest.internal.registeredElectricHoes["industrialtest:"..config.name.."_active"]=true
-	end
-	industrialtest.internal.registeredElectricHoes["industrialtest:"..config.name]=true
 end
-local definition={
-	name="electric_hoe",
-	displayName=S("Electric Hoe")
-}
-if industrialtest.mclAvailable then
-	definition.inactiveDigSpeed=1
-	definition.digLevel=2
-	definition.activeDigSpeed=7
+
+function industrialtest.ElectricHoeBase.getOpPower(self,itemstack)
+	return 50
 end
-registerElectricHoe(definition)
+
+industrialtest.ElectricHoe=table.copy(industrialtest.ElectricHoeBase)
+industrialtest.internal.unpackTableInto(industrialtest.ElectricHoe,{
+	name="industrialtest:electric_hoe",
+	description=S("Electric Hoe"),
+	inventoryImage="industrialtest_electric_hoe.png",
+	digLevel=0,
+	digSpeedClass=4,
+	active={
+		digSpeed=3
+	}
+})
+
+industrialtest.ElectricHoe:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:electric_hoe",
@@ -211,17 +162,25 @@ minetest.register_craft({
 		{"industrialtest:re_battery",""}
 	}
 })
+
 if industrialtest.mclAvailable then
-	registerElectricHoe({
-		name="diamond_electric_hoe",
-		displayName=S("Diamond Electric Hoe"),
-		inactiveDigSpeed=1,
-		digLevel=5,
-		activeDigSpeed=9
+	industrialtest.AdvancedElectricHoe=table.copy(industrialtest.ElectricHoeBase)
+	industrialtest.internal.unpackTableInto(industrialtest.AdvancedElectricHoe,{
+		name="industrialtest:advanced_electric_hoe",
+		description=S("Advanced Electric Hoe"),
+		inventoryImage="industrialtest_advanced_electric_hoe.png",
+		digLevel=0,
+		digSpeedClass=5,
+		active={
+			digSpeed=7
+		}
 	})
+
+	industrialtest.AdvancedElectricHoe:register()
+
 	minetest.register_craft({
 		type="shapeless",
-		output="industrialtest:diamond_electric_hoe",
+		output="industrialtest:advanced_electric_hoe",
 		recipe={
 			"industrialtest:electric_hoe",
 			industrialtest.elementKeys.diamond,

tools/electric_item.lua

@@ -0,0 +1,26 @@
+-- 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.ElectricItem=table.copy(industrialtest.Item)
+
+function industrialtest.ElectricItem.prepare(self,itemstack)
+	local meta=itemstack:get_meta()
+	if industrialtest.api.hasPowerStorage(meta) then
+		return
+	end
+	industrialtest.api.addPowerStorage(meta,self.capacity,self.flow,"n/a")
+	industrialtest.api.updateItemPowerText(itemstack)
+end

tools/electric_saber.lua

@@ -14,162 +14,95 @@
 -- You should have received a copy of the GNU General Public License
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+-- This entire code is super hacky, I'm aware.
+
 local S=minetest.get_translator("industrialtest")
+industrialtest.ElectricSaberBase=table.copy(industrialtest.ActivatedElectricTool)
+industrialtest.internal.unpackTableInto(industrialtest.ElectricSaberBase,{
+	fullPunchInterval=0.5,
+	digs={"snappy"},
+	hits={"fleshy"},
+	capacity=100000,
+	flow=industrialtest.api.hvPowerFlow
+})
 
-local electricSaber={}
-
-electricSaber.afterUse=function(itemstack,config)
-	local meta=itemstack:get_meta()
-	industrialtest.api.addPowerToItem(itemstack,-20)
-	if meta:get_int("industrialtest.powerAmount")<20 then
-		itemstack:set_name("industrialtest:"..config.name)
-	end
-	return itemstack
+function industrialtest.ElectricSaberBase.createActiveDefinitionTable(self)
+	self.define.onUse=false
+	return industrialtest.ActivatedElectricTool.createActiveDefinitionTable(self)
 end
 
-local function registerElectricSaber(config)
-	local definition={
-		description=config.displayName,
-		inventory_image="industrialtest_"..config.name..".png",
-		after_use=function()
-			-- Hack to make sure that saber won't be destroyed when has 0 EU
-			return nil
-		end,
-		_industrialtest_powerStorage=true,
-		_industrialtest_powerCapacity=10000,
-		_industrialtest_powerFlow=industrialtest.api.lvPowerFlow,
-		_industrialtest_inactiveName="industrialtest:"..config.name
-	}
-	if industrialtest.mtgAvailable then
-		definition.groups={
-			sword=1
-		}
-		definition.tool_capabilities={
-			full_punch_interval=0.5,
-			max_drop_level=config.maxDropLevel,
-			groupcaps={
-				snappy={
-					times=config.inactiveTimes,
-					maxlevel=config.maxLevel
-				}
-			},
-			damage_groups={fleshy=config.inactiveDamage}
-		}
-	elseif industrialtest.mclAvailable then
-		definition.groups={
-			weapon=1,
-			sword=1,
-			dig_speed_class=config.digSpeedClass
-		}
-		definition.tool_capabilities={
-			full_punch_interval=0.5,
-			max_drop_level=config.maxDropLevel,
-			damage_groups={fleshy=config.inactiveDamage}
-		}
-		definition._mcl_toollike_wield=true
-		definition._mcl_diggroups={
-			swordy={
-				speed=config.inactiveDigSpeed,
-				level=config.digLevel,
-				uses=-1
-			},
-			swordy_cobweb={
-				speed=config.inactiveDigSpeed,
-				level=config.digLevel,
-				uses=-1
-			}
-		}
+function industrialtest.ElectricSaberBase.hitUse(self,itemstack,user,pointed)
+	if self:canActivate(itemstack) and pointed.type=="object" then
+		-- pointed is a ObjectRef
+		industrialtest.api.addPowerToItem(itemstack,-self:getOpPower(itemstack))
+		local toolCapabilities={damage_groups={}}
+		for _,hitType in ipairs(self.hits) do
+			toolCapabilities.damage_groups[hitType]=self.active.damage
 		end
-	minetest.register_tool("industrialtest:"..config.name,definition)
-	definition=table.copy(definition)
-	if industrialtest.mtgAvailable then
-		definition.tool_capabilities.groupcaps.snappy.times=config.activeTimes
-		definition.tool_capabilities.damage_groups.fleshy=config.activeDamage
-	elseif industrialtest.mclAvailable then
-		definition.tool_capabilities.damage_groups.fleshy=config.activeDamage
-		definition._mcl_diggroups.swordy.speed=config.activeDigSpeed
-		definition._mcl_diggroups.swordy_cobweb.speed=config.activeDigSpeed
+		pointed.ref:punch(user,nil,toolCapabilities)
+		return true
 	end
-	definition.groups.not_in_creative_inventory=1
-	definition.after_use=function(itemstack)
-		return electricSaber.afterUse(itemstack,config)
-	end
-	minetest.register_tool("industrialtest:"..config.name.."_active",definition)
-	industrialtest.internal.registeredElectricSabers["industrialtest:"..config.name]=true
-	industrialtest.internal.registeredElectricSabers["industrialtest:"..config.name.."_active"]=true
+	return false
 end
-local definition={
-	name="electric_saber",
-	displayName=S("Electric Saber")
-}
-if industrialtest.mtgAvailable then
-	definition.maxDropLevel=1
-	definition.inactiveTimes={[1]=10,[2]=5.6,[3]=4}
-	definition.maxLevel=3
-	definition.inactiveDamage=1
-	definition.activeTimes={[1]=2.0,[2]=0.8,[3]=0.4}
-	definition.activeDamage=6
-elseif industrialtest.mclAvailable then
-	definition.digSpeedClass=4
-	definition.maxDropLevel=4
-	definition.inactiveDamage=1
-	definition.inactiveDigSpeed=1
-	definition.digLevel=4
-	definition.activeDamage=6
-	definition.activeDigSpeed=7
+
+function industrialtest.ElectricSaberBase.afterUse(self,itemstack,user,node,digparams)
+	industrialtest.ActivatedElectricTool.afterUse(self,itemstack,user,node,digparams)
+	itemstack:set_name(self.name)
+	return true
 end
-registerElectricSaber(definition)
+
+function industrialtest.ElectricSaberBase.getOpPower(self,itemstack)
+	return 500
+end
+
+industrialtest.ElectricSaber=table.copy(industrialtest.ElectricSaberBase)
+industrialtest.internal.unpackTableInto(industrialtest.ElectricSaber,{
+	name="industrialtest:electric_saber",
+	description=S("Electric Saber"),
+	inventoryImage="industrialtest_electric_saber.png",
+	digLevel=0,
+	digSpeedClass=4,
+	active={
+		digSpeed=7,
+		times={[1]=0.7,[2]=0.5,[3]=0.2,[4]=0.15},
+		damage=3
+	}
+})
+
+industrialtest.ElectricSaber:register()
+
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:electric_saber",
 	recipe={
-		{"industrialtest:refined_iron_ingot"},
-		{"industrialtest:refined_iron_ingot"},
-		{"industrialtest:re_battery"}
+		{industrialtest.elementKeys.yellowDust,"industrialtest:advanced_alloy",""},
+		{industrialtest.elementKeys.yellowDust,"industrialtest:advanced_alloy",""},
+		{"industrialtest:carbon_plate","industrialtest:energy_crystal","industrialtest:carbon_plate"}
 	}
 })
-definition={
-	name="diamond_electric_saber",
-	displayName=S("Diamond Electric Saber")
-}
-if industrialtest.mtgAvailable then
-	definition.maxDropLevel=1
-	definition.inactiveTimes={[1]=10,[2]=5.6,[3]=4}
-	definition.maxLevel=3
-	definition.inactiveDamage=1
-	definition.activeTimes={[1]=2.0,[2]=0.8,[3]=0.4}
-	definition.activeDamage=9
-elseif industrialtest.mclAvailable then
-	definition.digSpeedClass=5
-	definition.maxDropLevel=5
-	definition.inactiveDamage=1
-	definition.inactiveDigSpeed=1
-	definition.digLevel=5
-	definition.activeDamage=9
-	definition.activeDigSpeed=9
-end
-registerElectricSaber(definition)
+
+industrialtest.AdvancedElectricSaber=table.copy(industrialtest.ElectricSaberBase)
+industrialtest.internal.unpackTableInto(industrialtest.AdvancedElectricSaber,{
+	name="industrialtest:advanced_electric_saber",
+	description=S("Advanced Electric Saber"),
+	inventoryImage="industrialtest_advanced_electric_saber.png",
+	digLevel=0,
+	digSpeedClass=5,
+	active={
+		digSpeed=8,
+		times={[1]=0.5,[2]=0.2,[3]=0.15,[4]=0.1},
+		damage=5
+	}
+})
+
+industrialtest.AdvancedElectricSaber:register()
+
 minetest.register_craft({
 	type="shapeless",
-	output="industrialtest:diamond_electric_saber",
+	output="industrialtest:advanced_electric_saber",
 	recipe={
 		"industrialtest:electric_saber",
 		industrialtest.elementKeys.diamond,
 		industrialtest.elementKeys.diamond
 	}
 })
-
-minetest.register_on_punchplayer(function(player,hitter)
-	local itemstack=hitter:get_wielded_item()
-	if industrialtest.internal.registeredElectricSabers[itemstack:get_name()] then
-		local meta=itemstack:get_meta()
-		if meta:get_int("industrialtest.powerAmount")>=20 then
-			industrialtest.api.addPowerToItem(itemstack,-20)
-			hitter:set_wielded_item(itemstack)
-			local def=minetest.registered_tools[itemstack:get_name().."_active"]
-			player:set_hp(player:get_hp()-def.tool_capabilites.damage_groups.fleshy)
-			return true
-		end
-	end
-	return false
-end)

tools/electric_tool.lua

@@ -0,0 +1,76 @@
+-- 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.ElectricTool=table.copy(industrialtest.Tool)
+industrialtest.internal.unpackTableInto(industrialtest.ElectricTool,{
+	prepare=industrialtest.ElectricItem.prepare
+})
+
+function industrialtest.ElectricTool.createDefinitionTable(self)
+	local def=industrialtest.Tool.createDefinitionTable(self)
+	def.after_use=function()
+		-- Hack to make sure that chainsaw won't be destroyed when has 0 EU
+		return nil
+	end
+	return def
+end
+
+function industrialtest.ElectricTool.onPlace(self,itemstack,user,pointed)
+	self:prepare(itemstack)
+
+	local meta=itemstack:get_meta()
+	local opPower=self:getOpPower(itemstack)
+	if meta:get_int("industrialtest.powerAmount")<opPower then
+		return false
+	end
+
+	if self:use(itemstack,user,pointed) then
+		industrialtest.api.addPowerToItem(itemstack,-opPower)
+	end
+	return true
+end
+
+function industrialtest.ElectricTool.onUse(self,itemstack,user,pointed)
+	self:prepare(itemstack)
+
+	if user:is_player() then
+		local controls=user:get_player_control()
+		if controls.sneak and self:changeMode(itemstack) then
+			return true
+		end
+	end
+
+	local meta=itemstack:get_meta()
+	local opPower=self:getOpPower(itemstack)
+	if meta:get_int("industrialtest.powerAmount")<opPower then
+		return false
+	end
+
+	if self:hitUse(itemstack,user,pointed) then
+		industrialtest.api.addPowerToItem(itemstack,-opPower)
+	end
+	return true
+end
+
+function industrialtest.ElectricTool.changeMode(self,itemstack)
+	-- dummy function
+	return false
+end
+
+function industrialtest.ElectricTool.getOpPower(self,itemstack)
+	-- dummy function
+	return 0
+end

tools/fluid_container_item.lua

@@ -0,0 +1,27 @@
+-- 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.FluidContainerItem=table.copy(industrialtest.Item)
+
+function industrialtest.FluidContainerItem.prepare(self,itemstack)
+	if industrialtest.api.itemHasFluidStorage(itemstack) then
+		return
+	end
+	local meta=itemstack:get_meta()
+	meta:set_int("industrialtest.fluidAmount",0)
+	meta:set_int("industrialtest.fluidCapacity",self.capacity)
+	industrialtest.api.updateItemFluidText(itemstack)
+end

tools/fluid_storage.lua

@@ -0,0 +1,45 @@
+-- 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/>.
+
+local S=minetest.get_translator("industrialtest")
+
+industrialtest.FuelCan=table.copy(industrialtest.FluidContainerItem)
+industrialtest.internal.unpackTableInto(industrialtest.FuelCan,{
+	name="industrialtest:fuel_can",
+	description=S("Fuel Can"),
+	inventoryImage="industrialtest_fuel_can.png",
+	capacity=10000
+})
+
+function industrialtest.FuelCan.createDefinitionTable(self)
+	local def=industrialtest.FluidContainerItem.createDefinitionTable(self)
+	def.groups._industrialtest_fueled=1
+	def.groups._industrialtest_fuel=1
+	return def
+end
+
+industrialtest.FuelCan:register()
+
+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"}
+	}
+})
+