Describe Canning Machine 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)

guide.lua

@@ -0,0 +1,153 @@
+-- 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 pages={
+	{
+		name="introduction",
+		title=S("Introduction"),
+		icon=industrialtest.elementKeys.paper,
+		content=[[
+			<big>Introduction</big>
+			<left>
+				IndustrialTest implements finite power functionality which can be used to perform various tasks using generators and consumers. Such features are not a new thing in Luanti, as there are older mods which do that already. This mod, however, proves to be more flexible.
+			</left>
+		]]
+	},
+	{
+		name="electricalNetwork",
+		title=S("Electrical network"),
+		icon="industrialtest:insulated_copper_cable",
+		content=[[
+			<big>Electrical network</big>
+			<left>
+				In order to attach electricity consumers to power sources (like generators, batteries, further just called generators) electrical network is used. Consumers can get connected either directly to generators or through various cables. Each generator can output certain voltage (this is actually amperage, however since this mod doesn't simulate electricity accurately, it's called voltage), the same situation is for consumers as they can only handle up to certain voltage.
+				Figure 1 shows voltage levels present in this mod.
+				If voltage is too high for cable it will melt without dropping anything while consumer will explode also without dropping anything and possibly destroying terrain around. Power capacity is measured in EU (Energy Units) and the voltage is EU/update.
+			</left>
+			<mono>
+				--------------------------------------------
+				| Voltage level | EU/update  | Cable       |
+				--------------------------------------------
+				| LV            | 600        | Tin         |
+				| MV            | 2400       | Copper      |
+				| HV            | 10200      | Gold        |
+				| EV            | 40800      | Iron        |
+				| IV            | 163800     | Glass Fibre |
+				--------------------------------------------
+				Figure 1. Voltage levels and respective cables
+			</mono>
+		]]
+	},
+	{
+		name="cableFormer",
+		title=S("Cable Former"),
+		icon="industrialtest:cable_former",
+		content=[[
+			<big>Cable Former</big>
+			<left>
+				Cable Former can be used to produce cables with higher material efficiency. It can, however, only produce cables from metals so for example Glass Fibre Cable can't be produced in it.
+			</left>
+			<mono>
+				---------------------------------------
+				| Input voltage level | LV            |
+				| Recipe type         | Cable forming |
+				| Power capacity      | 1400 EU       |
+				| Power per operation | 80 EU         |
+				---------------------------------------
+				Figure 1. Machine information for Cable Former
+			</mono>
+		]]
+	},
+	{
+		name="canningMachine",
+		title=S("Canning Machine"),
+		icon="industrialtest:canning_machine",
+		content=[[
+			<big>Canning Machine</big>
+			<left>
+				Canning Machine is used to move certain fluid from one item to another. The common usage is to refill fuel in Jetpack or Fuel Can.
+			</left>
+			<mono>
+				---------------------------------------
+				| Input voltage level     | LV        |
+				| Power per operation     | 200 EU    |
+				| Power capacity          | 1200 EU   |
+				| Canning completion time | 5 seconds |
+				---------------------------------------
+				Figure 1. Machine information for Canning Machine
+			</mono>
+		]]
+	}
+}
+
+local function getGuideFormspec(playerName,pageName)
+	local formspec={
+		"formspec_version[4]",
+		"size[15,10.8]",
+		"label[0.1,0.2;"..S("IndustrialTest Guide").."]",
+		--"scrollbaroptions[]",
+		"scrollbar[3.6,0.4;0.5,10.3;vertical;scrollbarList;0]",
+		"scroll_container[0.1,0.4;4,10.3;scrollbarList;vertical]"
+	}
+
+	-- Contents sidebar
+	local PAGE_BUTTON_HEIGHT=0.7
+	for i,page in ipairs(pages) do
+		table.insert(formspec,string.format("container[0,%f]",(i-1)*PAGE_BUTTON_HEIGHT))
+		table.insert(formspec,string.format("item_image[0,0;%f,%f;%s]",PAGE_BUTTON_HEIGHT,PAGE_BUTTON_HEIGHT,page.icon))
+		table.insert(formspec,string.format("button[%f,0;%f,%f;%s;%s]",PAGE_BUTTON_HEIGHT+0.05,3.45-PAGE_BUTTON_HEIGHT,PAGE_BUTTON_HEIGHT,page.name,page.title))
+		table.insert(formspec,"container_end[]")
+	end
+	table.insert(formspec,"scroll_container_end[]")
+
+	if pageName then
+		for _,page in ipairs(pages) do
+			if page.name==pageName then
+				table.insert(formspec,string.format("hypertext[4.2,0.4;10.7,10.3;content;%s]",page.content))
+				break
+			end
+		end
+	end
+
+	return table.concat(formspec,"")
+end
+
+local function showGuide(playerName,page)
+	minetest.show_formspec(playerName,"industrialtest:guide",getGuideFormspec(playerName,page))
+	return true
+end
+
+local function handleGuideFields(player,formname,fields)
+	if formname~="industrialtest:guide" then
+		return
+	end
+
+	for _,page in ipairs(pages) do
+		if fields[page.name] then
+			minetest.close_formspec(player:get_player_name(),formname)
+			showGuide(player:get_player_name(),page.name)
+			break
+		end
+	end
+end
+minetest.register_on_player_receive_fields(handleGuideFields)
+
+minetest.register_chatcommand("industrialtest_guide",{
+	description=S("Shows graphical guide for content and features provided by IndustrialTest"),
+	func=showGuide
+})

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/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 output=self:getCraftResult(srcSlot)
-		maxSrcTime=output.time*self.efficiency
+		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,25 +209,38 @@ function industrialtest.SimpleElectricItemProcessor.activeUpdate(self,pos,elapse
 	meta:set_int("srcTime",srcTime)
 
 	if srcTime>=maxSrcTime then
-		local output=self:getCraftResult(srcSlot)
-		local usedItems=srcSlot:get_count()-output.src:get_count()
-		local multiplier=1
-		if srcSlot:get_count()>=speed*usedItems then
-			multiplier=speed
-		end
-		if output.item:get_count()>0 then
-			output.item:set_count(output.item:get_count()*multiplier)
-			inv:add_item("dst",output.item)
+		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
+			if srcSlot:get_count()>=speed*usedItems then
+				multiplier=speed
+			end
+			if output.item:get_count()>0 then
+				output.item:set_count(output.item:get_count()*multiplier)
+				inv:add_item("dst",output.item)
+			end
+			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)
-		srcSlot:set_count(srcSlot:get_count()-multiplier*usedItems)
-		inv:set_stack("src",1,srcSlot)
 	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

nodes.lua

@@ -489,3 +489,128 @@ 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
+	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,
+		_mcl_fences_baseitem="industrialtest:iron_plate",
+		_mcl_fences_stickreplacer="industrialtest:iron_plate"
+	})
+	-- 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

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
 })