Describe electric toolset in guide

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

@@ -25,6 +25,16 @@ local function createItemFluidStorageText(itemstack)
 	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_string("industrialtest.fluidType","ignore")
+end
+
 -- \brief Check if itemstack contains fluid storage
 -- \param itemstack ItemStack
 -- \returns bool

api/registration.lua

@@ -307,6 +307,65 @@ 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

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
@@ -507,6 +538,7 @@ if industrialtest.mclAvailable then
 	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")
@@ -742,6 +774,7 @@ elseif industrialtest.mtgAvailable then
 	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

@@ -503,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,
@@ -533,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
@@ -554,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",

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

@@ -56,10 +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")
@@ -96,6 +98,7 @@ dofile(modpath.."/tools/wrench.lua")
 
 dofile(modpath.."/upgrades.lua")
 dofile(modpath.."/craftitems.lua")
+dofile(modpath.."/guide.lua")
 dofile(modpath.."/nodes.lua")
 if industrialtest.config.developerMode then
 	dofile(modpath.."/utils.lua")

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/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

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

@@ -166,6 +166,8 @@ function industrialtest.Miner.onConstruct(self,pos)
 	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
 
@@ -184,13 +186,13 @@ function industrialtest.Miner.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.2;"..S("Drill").."]",
+		"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.8;"..S("Pipe").."]",
+		"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.4;"..S("Scanner").."]",
+		"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]",
@@ -283,6 +285,14 @@ function industrialtest.Miner.update(self,pos,elapsed,meta,inv)
 	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)
@@ -375,8 +385,27 @@ function industrialtest.Miner.placeMiningPipe(minerPos,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",

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/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]"
@@ -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/wind_mill.lua

@@ -76,13 +76,14 @@ function industrialtest.WindMill.action(self,pos)
 		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),

nodes.lua

@@ -489,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

tools/batpack.lua

@@ -69,8 +69,8 @@ industrialtest.internal.unpackTableInto(industrialtest.LapPack,{
 	description=S("LapPack"),
 	inventoryImage="industrialtest_lappack_v_inv.png",
 	modelImage="industrialtest_lappack_v.png",
-	capacity=60000,
+	capacity=300000,
-	flow=industrialtest.api.lvPowerFlow
+	flow=industrialtest.api.mvPowerFlow
 })
 
 industrialtest.LapPack:register()
@@ -79,7 +79,7 @@ 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}
 	}

tools/jetpack.lua

@@ -25,7 +25,7 @@ function industrialtest.JetpackBase.update(self, player, inv, itemstack, dtime)
 	local playerName = player:get_player_name()
 	local control = player:get_player_control()
 	if control.jump and self:tryFly(itemstack) then
-		self.addYVelocityClamped(player,1,10)
+		industrialtest.internal.addYVelocityClamped(player,1,10)
 		if not soundHandles[playerName] then
 			local pos = player:get_pos()
 			local handle = minetest.sound_play("industrialtest_jetpack_loop", {
@@ -47,15 +47,6 @@ function industrialtest.JetpackBase.update(self, player, inv, itemstack, dtime)
 	return false
 end
 
-function industrialtest.JetpackBase.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
-
 industrialtest.Jetpack=table.copy(industrialtest.JetpackBase)
 industrialtest.internal.unpackTableInto(industrialtest.Jetpack,{
 	-- _v is hack to suppress "Registered armor doesn't have material at the end of registration name" warning from 3D Armor.

tools/quantum_suit.lua

@@ -87,7 +87,7 @@ industrialtest.internal.unpackTableInto(industrialtest.QuantumBodyarmor,{
 	part="torso",
 	modelImage="industrialtest_quantum_bodyarmor.png",
 	update=industrialtest.JetpackBase.update,
-	addYVelocityClamped=industrialtest.JetpackBase.addYVelocityClamped,
+	addYVelocityClamped=industrialtest.internal.addYVelocityClamped,
 	tryFly=industrialtest.ElectricJetpack.tryFly
 })