Saving work

README.md

@@ -9,17 +9,15 @@ Currently IndustrialTest supports following games:
 ## Additional dependencies
 - Minetest Game
     - [3D Armor](https://content.minetest.net/packages/stu/3d_armor)
-- VoxeLibre
+- MineClone2
     - none
 
 ## Optional dependencies
 - [Rubber Addon for MineClone](https://content.minetest.net/packages/biochemist/mcl_rubber)
 - [Pipeworks](https://content.minetest.net/packages/VanessaE/pipeworks)
-- [Logistica](https://content.minetest.net/packages/ZenonSeth/logistica)
 - [Mesecons](https://content.minetest.net/packages/Jeija/mesecons)
 
 ## Contributors
 - mrkubax10 <mrkubax10@onet.pl or mrkubax10 at irc.libera.chat> [programming, some graphics]
-- HandfulOfFrogs <<handfuloffrogs@gmail.com>> [some programming, graphics]
 - LuanHawk <Discord: LuanHawk#8733> [lead graphics]
 - Migdyn <<temp1@cubesoftware.xyz>> [graphics]

TEXTURES_TODO.md

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

api.lua

@@ -0,0 +1,896 @@
+-- IndustrialTest
+-- Copyright (C) 2023 mrkubax10
+
+-- This program is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-- GNU General Public License for more details.
+
+-- You should have received a copy of the GNU General Public License
+-- along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+local S=minetest.get_translator("industrialtest")
+
+industrialtest.api={}
+industrialtest.api.maceratorRecipes={}
+industrialtest.api.compressorRecipes={}
+industrialtest.api.extractorRecipes={}
+industrialtest.api.cableFormerRecipes={}
+industrialtest.api.geothermalGeneratorFuels={}
+industrialtest.api.waterMillFuels={}
+industrialtest.api.rotaryMaceratorModifiers={}
+industrialtest.api.storageCells={}
+
+industrialtest.api.lvPowerFlow=600
+industrialtest.api.mvPowerFlow=2400
+industrialtest.api.hvPowerFlow=10200
+industrialtest.api.evPowerFlow=40800
+industrialtest.api.ivPowerFlow=163800
+
+industrialtest.internal.clamp=function(num,min,max)
+	return math.max(math.min(num,max),min)
+end
+
+-- \brief Adds power storage to metadata
+-- \param capacity How much EU item/node can store
+-- \param flow How much EU can flow in or out item/node per industrialtest.updateDelay
+-- \param ioConfig Input/Output configuration in following side order: -X, +X, -Y, +Y, -Z, +Z
+--                 a - bidirectional, i - input, o - output
+-- \returns nil
+industrialtest.api.addPowerStorage=function(meta,capacity,flow,ioConfig)
+	meta:set_int("industrialtest.powerCapacity",capacity)
+	meta:set_int("industrialtest.powerFlow",flow)
+	meta:set_int("industrialtest.powerAmount",0)
+	meta:set_string("industrialtest.ioConfig",ioConfig)
+end
+-- \brief Takes rotated node and side and outputs normalized side that can be used for ioConfig lookups
+-- \param pos Vector with node position
+-- \param side Node side. See industrialtest.api.addPowerStorage for possible values
+-- \returns Normalized side or in case of failure side argument back
+industrialtest.api.normalizeSide=function(pos,side)
+	local node=minetest.get_node(pos)
+	-- FIXME: improve code quality there
+	local translation={
+		[0]={
+			1,2,3,4,5,6
+		},
+		[1]={
+			5,6,3,4,2,1
+		},
+		[2]={
+			2,1,3,4,6,5
+		},
+		[3]={
+			6,5,3,4,1,2
+		}
+	}
+	if node.param2>3 then
+		return side
+	end
+	return translation[node.param2][side]
+end
+-- \brief Checks if metadata contains power storage
+-- \param meta MetaDataRef which should be checked
+-- \returns true if metadata contains power storage, false otherwise
+industrialtest.api.hasPowerStorage=function(meta)
+	local values={"industrialtest.powerCapacity","industrialtest.powerFlow","industrialtest.powerAmount","industrialtest.ioConfig"}
+	for _,value in ipairs(values) do
+		if not meta:contains(value) then
+			return false
+		end
+	end
+	return true
+end
+-- \brief Updates itemstack description to show current power storage information, additionally updates item wear bar.
+--        Function doesn't check if itemstack contains power storage so you should be sure that it does before calling this function
+-- \param itemstack ItemStack which should be updated
+-- \returns nil
+industrialtest.api.updateItemPowerText=function(itemstack)
+	local meta=itemstack:get_meta()
+	local def=minetest.registered_tools[itemstack:get_name()]
+	local desc=meta:contains("industrialtest.descriptionOverride") and meta:get_string("industrialtest.descriptionOverride") or def.description
+	meta:set_string("description",S("@1\n@2 / @3 EU",desc,meta:get_int("industrialtest.powerAmount"),meta:get_int("industrialtest.powerCapacity")))
+	itemstack:set_wear(65535-meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*65534)
+end
+-- \brief Adds power storage to item depending on it's definition
+-- \param itemstack ItemStack to which item storage should be added
+-- \returns true if power storage was successfully added, false otherwise
+industrialtest.api.preparePowerStorageItem=function(itemstack)
+	local meta=itemstack:get_meta()
+	local def=minetest.registered_tools[itemstack:get_name()]
+	if industrialtest.api.hasPowerStorage(meta) or not def or not def._industrialtest_powerStorage or not def._industrialtest_powerCapacity or not def._industrialtest_powerFlow then
+		return false
+	end
+	industrialtest.api.addPowerStorage(meta,def._industrialtest_powerCapacity,def._industrialtest_powerFlow,"n/a")
+	industrialtest.api.updateItemPowerText(itemstack)
+	return true
+end
+-- \brief Sets uses metadata value depending on item's definition
+-- \param itemstack ItemStack which should be altered
+-- \returns true if value was successfully added, false otherwise
+industrialtest.api.prepareToolItem=function(itemstack)
+	local def=minetest.registered_tools[itemstack:get_name()]
+	if not def then
+		return false
+	end
+	if def._industrialtest_tool and def.tool_capabilities and def.tool_capabilities.uses then
+		local meta=itemstack:get_meta()
+		meta:set_int("industrialtest.uses",def.tool_capabilities.uses)
+		return true
+	elseif def.groups and def.groups._industrialtest_emptyOnConstruct and itemstack:get_wear()==0 then
+		itemstack:set_wear(65534)
+		return true
+	end
+	return false
+end
+-- \brief Adds wear to item after it's use
+-- \param itemstack ItemStack to which wear should be added
+-- \returns nil
+industrialtest.api.afterToolUse=function(itemstack)
+	local meta=itemstack:get_meta()
+	local def=minetest.registered_tools[itemstack:get_name()]
+	if not def or not def._industrialtest_tool or not def.tool_capabilities or not def.tool_capabilities.uses then
+		return
+	end
+	if not meta:contains("industrialtest.uses") then
+		industrialtest.prepareToolItem(itemstack)
+	end
+	local uses=meta:get_int("industrialtest.uses")-1
+	if uses==0 then
+		itemstack:set_count(0)
+		minetest.sound_play({name="default_tool_breaks"},{
+			gain=1,
+			fade=0,
+			pitch=1
+		},true)
+		return
+	end
+	meta:set_int("industrialtest.uses",uses)
+	itemstack:set_wear(65535-uses/def.tool_capabilities.uses*65535)
+end
+
+-- \brief Check if itemstack contains fluid storage
+-- \param itemstack ItemStack
+-- \returns bool
+industrialtest.api.itemHasFluidStorage=function(itemstack)
+	local values={"industrialtest.fluidAmount","industrialtest.fluidCapacity"}
+	local meta=itemstack:get_meta()
+	for _,value in ipairs(values) do
+		if not meta:contains(value) then
+			return false
+		end
+	end
+	return true
+end
+
+-- \brief Updates itemstack description and wear depending on contained fluid
+-- \param itemstack ItemStack
+-- \returns nil
+industrialtest.api.updateItemFluidText=function(itemstack)
+	local meta=itemstack:get_meta()
+	local def=itemstack:get_definition()
+	meta:set_string("description",S("@1\n@2 / @3 mB",def.description,meta:get_int("industrialtest.fluidAmount"),meta:get_int("industrialtest.fluidCapacity")))
+	itemstack:set_wear(65535-meta:get_int("industrialtest.fluidAmount")/meta:get_int("industrialtest.fluidCapacity")*65534)
+end
+
+-- \brief Prepares itemstack containing fluid storage
+-- \param itemstack ItemStack
+-- \returns bool
+industrialtest.api.prepareFluidStorageItem=function(itemstack)
+	local meta=itemstack:get_meta()
+	local def=itemstack:get_definition()
+	if industrialtest.api.itemHasFluidStorage(itemstack) or not def.groups or not def.groups._industrialtest_fluidStorage or not def._industrialtest_fluidCapacity then
+		return false
+	end
+	meta:set_int("industrialtest.fluidAmount",0)
+	meta:set_int("industrialtest.fluidCapacity",def._industrialtest_fluidCapacity)
+	industrialtest.api.updateItemFluidText(itemstack)
+	return true
+end
+
+-- \brief Adds fluid amount to item fluid storage
+-- \param itemstack ItemStack
+-- \param amount number
+-- \returns number
+industrialtest.api.addFluidToItem=function(itemstack,amount)
+	local meta=itemstack:get_meta()
+	if not industrialtest.api.itemHasFluidStorage(itemstack) then
+		return 0
+	end
+	local fluidAmount=meta:get_int("industrialtest.fluidAmount")
+	local fluidCapacity=meta:get_int("industrialtest.fluidCapacity")
+	local prevFluidAmount=fluidAmount
+	fluidAmount=industrialtest.internal.clamp(fluidAmount+amount,0,fluidCapacity)
+	meta:set_int("industrialtest.fluidAmount",fluidAmount)
+	industrialtest.api.updateItemFluidText(itemstack)
+	return fluidAmount-prevFluidAmount
+end
+
+-- \brief Adds fluid to destination itemstack while subtracting it from source itemstack's metadata
+-- \param srcItemstack ItemStack
+-- \param itemstack ItemStack
+-- \param amount number
+-- \returns number
+industrialtest.api.transferFluidToItem=function(srcItemstack,itemstack,amount)
+	local meta=srcItemstack:get_meta()
+	local flow=math.min(meta:get_int("industrialtest.fluidAmount"),amount)
+	if flow==0 then
+		return 0
+	end
+	local actualFlow=industrialtest.api.addFluidToItem(itemstack,flow)
+	meta:set_int("industrialtest.fluidAmount",meta:get_int("industrialtest.fluidAmount")-actualFlow)
+	industrialtest.api.updateItemFluidText(srcItemstack)
+	return actualFlow
+end
+
+-- \brief Checks if power storage is fully charged
+-- \param meta MetaDataRef which should be checked
+-- \returns true if power storage is fully charged, false otherwise
+industrialtest.api.isFullyCharged=function(meta)
+	return meta:get_int("industrialtest.powerAmount")>=meta:get_int("industrialtest.powerCapacity")
+end
+-- \brief Adds power to power storage. Function doesn't check if meta contains power storage so you must be sure that it does.
+-- \param meta MetaDataRef to which power should be added
+-- \param amount Amount of power to add
+-- \returns How much of power was actually added
+industrialtest.api.addPower=function(meta,amount)
+	local powerAmount=meta:get_int("industrialtest.powerAmount")
+	local powerCapacity=meta:get_int("industrialtest.powerCapacity")
+	local prevPowerAmount=powerAmount
+	powerAmount=industrialtest.internal.clamp(powerAmount+amount,0,powerCapacity)
+	meta:set_int("industrialtest.powerAmount",powerAmount)
+	return powerAmount-prevPowerAmount
+end
+-- \brief Adds power to itemstack. Function checks if itemstack has power storage.
+-- \param itemstack ItemStack to which add power
+-- \param amount How much power to add
+-- \returns Amount of power added
+industrialtest.api.addPowerToItem=function(itemstack,amount)
+	local meta=itemstack:get_meta()
+	if not industrialtest.api.hasPowerStorage(meta) then
+		return 0
+	end
+	local added=industrialtest.api.addPower(meta,amount)
+	industrialtest.api.updateItemPowerText(itemstack)
+	return added
+end
+-- \brief Adds power to destination metadata while subtracting it from source metadata
+-- \Param srcMeta MetaDataRef from which take power
+-- \param destMeta MetaDataRef to which add power
+-- \returns How much of power was actually transferred
+industrialtest.api.transferPower=function(srcMeta,destMeta,amount)
+	local currentFlow=math.min(srcMeta:get_int("industrialtest.powerAmount"),amount)
+	if currentFlow==0 then
+		return 0
+	end
+	local actualFlow=industrialtest.api.addPower(destMeta,currentFlow)
+	srcMeta:set_int("industrialtest.powerAmount",srcMeta:get_int("industrialtest.powerAmount")-actualFlow)
+	return actualFlow
+end
+-- \brief Adds power to destination itemstack while subtracting it from source metadata
+-- \param srcMeta MetaDataRef from which take power
+-- \param itemstack ItemStack to which add power
+-- \param amount number
+-- \returns How much of power was actually transferred
+industrialtest.api.transferPowerToItem=function(srcMeta,itemstack,amount)
+	local currentFlow=math.min(srcMeta:get_int("industrialtest.powerAmount"),amount)
+	if currentFlow==0 then
+		return 0
+	end
+	local actualFlow=industrialtest.api.addPowerToItem(itemstack,currentFlow)
+	srcMeta:set_int("industrialtest.powerAmount",srcMeta:get_int("industrialtest.powerAmount")-actualFlow)
+	return actualFlow
+end
+-- \brief Adds power to destination metadata while subtracting it from source itemstack
+-- \param srcItemstack ItemStack from which subtract power
+-- \param meta MetaDataRef to which add power
+-- \param amount How much power should be transferred
+-- \returns How much of power was actually transferred
+industrialtest.api.transferPowerFromItem=function(srcItemstack,meta,amount)
+	local srcMeta=srcItemstack:get_meta()
+	local currentFlow=math.min(srcMeta:get_int("industrialtest.powerAmount"),amount)
+	if currentFlow==0 then
+		return 0
+	end
+	local actualFlow=industrialtest.api.addPower(meta,currentFlow)
+	industrialtest.api.addPowerToItem(srcItemstack,-actualFlow)
+	return actualFlow
+end
+
+-- \brief Transfers power from source node to it's network, if sides is set then power will be only transfered to network connected to that sides
+-- \param pos Vector with position of source node
+-- \param (optional) sides table with Vectors
+-- \param (optional) flowOverride number
+-- \returns two values: true if any neighbouring node has room for more power, false otherwise
+--                      true if any power was transferred, false otherwise
+industrialtest.api.powerFlow=function(pos,sides,flowOverride)
+	local meta=minetest.get_meta(pos)
+	-- if machine doesn't have network map then it's not capable of transferring power
+	local network=industrialtest.api.getNetwork(meta)
+	if not network or #network==0 then
+		return false,false
+	end
+	local endpointCount=0
+	for _,endpoint in ipairs(network) do
+		local endpointMeta=minetest.get_meta(endpoint.position)
+		if not industrialtest.api.isFullyCharged(endpointMeta) and (not sides or sides[endpoint.sourceSide]) then
+			endpointCount=endpointCount+1
+		end
+	end
+	if endpointCount==0 then
+		return false,false
+	end
+	local powerDistribution=math.floor((flowOverride and flowOverride or meta:get_int("industrialtest.powerFlow"))/endpointCount)
+	local transferred=false
+	local roomAvailable=false
+	for _,endpoint in ipairs(network) do
+		if not sides or sides[endpoint.sourceSide] then
+			local endpointMeta=minetest.get_meta(endpoint.position)
+			if powerDistribution<=endpoint.flow then
+				local transferredPower=industrialtest.api.transferPower(meta,endpointMeta,powerDistribution)
+				if transferredPower>0 then
+					transferred=true
+				end
+				local def=minetest.registered_nodes[minetest.get_node(endpoint.position).name]
+				if def then
+					local updateFormspec=def._industrialtest_updateFormspec
+					if updateFormspec then
+						updateFormspec(endpoint.position)
+					end
+					local onPowerFlow=def._industrialtest_onPowerFlow
+					if onPowerFlow and transferredPower>0 then
+						onPowerFlow(endpoint.position,industrialtest.api.getOppositeSide(endpoint.side),transferredPower)
+					end
+				end
+				minetest.get_node_timer(endpoint.position):start(industrialtest.updateDelay)
+				if not industrialtest.api.isFullyCharged(endpointMeta) then
+					roomAvailable=true
+				end
+			else
+				minetest.remove_node(endpoint.position)
+				industrialtest.internal.explode(endpoint.position,2)
+			end
+		end
+	end
+	return roomAvailable,transferred
+end
+
+local function addNodeToNetwork(pos,networkMasterPos)
+	local meta=minetest.get_meta(pos)
+	local networks={}
+	if meta:contains("industrialtest.networks") then
+		networks=minetest.deserialize(meta:get_string("industrialtest.networks"))
+	end
+	for _,network in ipairs(networks) do
+		if network.x==networkMasterPos.x and network.y==networkMasterPos.y and network.z==networkMasterPos.z then
+			return
+		end
+	end
+	table.insert(networks,networkMasterPos)
+	meta:set_string("industrialtest.networks",minetest.serialize(networks))
+end
+
+local function clampFlow(pos,flow)
+	local def=minetest.registered_nodes[minetest.get_node(pos).name]
+	local newFlow
+	if def.groups and def.groups._industrialtest_cable then
+		newFlow=def._industrialtest_cableFlow
+	else
+		local meta=minetest.get_meta(pos)
+		newFlow=meta:get_int("industrialtest.powerFlow")
+	end
+	return math.min(flow,newFlow)
+end
+
+-- \brief Creates network map starting from node at pos, optionally omitting node at omit
+-- \param pos vector
+-- \param (optional) addCables bool
+-- \param (optional) omit Vector
+-- \returns table with network map
+industrialtest.api.createNetworkMap=function(pos,addCables,omit)
+	local workers={}
+	local map={}
+	local connections=industrialtest.api.getConnections(pos,"i")
+	if #connections==0 then
+		return map
+	end
+	local sides={
+		["-1,0,0"]=1,
+		["1,0,0"]=2,
+		["0,-1,0"]=3,
+		["0,1,0"]=4,
+		["0,0,-1"]=5,
+		["0,0,1"]=6
+	}
+	local serializedSourcePos=pos.x..","..pos.y..","..pos.z
+	local visitedNodes={[serializedSourcePos]=true}
+	for _,conn in ipairs(connections) do
+		if not omit or conn.x~=omit.x or conn.y~=omit.y or conn.z~=omit.z then
+			visitedNodes[conn.x..","..conn.y..","..conn.z]=true
+			addNodeToNetwork(conn,pos)
+			local sideVector=vector.subtract(conn,pos)
+			local serializedSideVector=sideVector.x..","..sideVector.y..","..sideVector.z
+			local def=minetest.registered_nodes[minetest.get_node(conn).name]
+			if def.groups._industrialtest_cable then
+				table.insert(workers,{
+					position=conn,
+					targetPosition=conn,
+					distance=1,
+					flow=def._industrialtest_cableFlow,
+					targetFlow=0,
+					sourceSide=industrialtest.api.normalizeSide(pos,sides[serializedSideVector])
+				})
+				if addCables then
+					table.insert(map,{
+						position=conn,
+						distance=0
+					})
+				end
+			else
+				local meta=minetest.get_meta(conn)
+				table.insert(map,{
+					position=conn,
+					distance=0,
+					flow=meta:get_int("industrialtest.powerFlow"),
+					side=sides[serializedSideVector],
+					sourceSide=industrialtest.api.normalizeSide(pos,sides[serializedSideVector])
+				})
+			end
+		end
+	end
+	while #workers>0 do
+		for i=1,#workers do
+			local worker=workers[i]
+			connections=industrialtest.api.getConnections(worker.position,"i")
+			if #connections==0 then
+				table.remove(workers,i)
+				break
+			else
+				local directionAssigned=false
+				local foundNewNode=false
+				for _,conn in ipairs(connections) do
+					if not omit or conn.x~=omit.x or conn.y~=omit.y or conn.z~=omit.z then
+						local serializedPos=conn.x..","..conn.y..","..conn.z
+						if not visitedNodes[serializedPos] then
+							local def=minetest.registered_nodes[minetest.get_node(conn).name]
+							visitedNodes[serializedPos]=true
+							foundNewNode=true
+							addNodeToNetwork(conn,pos)
+							if def.groups._industrialtest_cable then
+								if directionAssigned then
+									table.insert(workers,{
+										position=conn,
+										targetPosition=conn,
+										distance=worker.distance+1,
+										flow=clampFlow(conn,worker.flow),
+										targetFlow=0,
+										sourceSide=worker.sourceSide
+									})
+								else
+									worker.targetPosition=conn
+									worker.distance=worker.distance+1
+									worker.targetFlow=clampFlow(conn,worker.flow)
+									directionAssigned=true
+								end
+								if addCables then
+									table.insert(map,{
+										position=conn,
+										distance=worker.distance+1,
+									})
+								end
+							else
+								local sideVector=vector.subtract(conn,worker.position)
+								table.insert(map,{
+									position=conn,
+									distance=worker.distance,
+									flow=clampFlow(conn,worker.flow),
+									side=sides[sideVector.x..","..sideVector.y..","..sideVector.z],
+									sourceSide=worker.sourceSide
+								})
+								if #connections==1 then
+									foundNewNode=false
+									break
+								end
+							end
+						end
+					end
+				end
+				if not foundNewNode then
+					table.remove(workers,i)
+					break
+				end
+				worker.position=worker.targetPosition
+				worker.flow=worker.targetFlow
+			end
+		end
+	end
+	return map
+end
+
+industrialtest.api.removeNodeFromNetwork=function(pos,nodePos)
+	local meta=minetest.get_meta(pos)
+	local network=minetest.deserialize(meta:get_string("industrialtest.network"))
+	local removed=false
+	for key,node in ipairs(network) do
+		if node.position.x==nodePos.x and node.position.y==nodePos.y and node.position.z==nodePos.z then
+			table.remove(network,key)
+			removed=true
+			break
+		end
+	end
+	if removed then
+		meta:set_string("industrialtest.network",minetest.serialize(network))
+	end
+end
+
+-- \brief Creates network map and writes it to node metadata at pos, optionally omitting node at omit
+-- \param pos Vector
+-- \param (optional) omit Vector
+-- \returns nil
+industrialtest.api.createNetworkMapForNode=function(pos,omit)
+	local meta=minetest.get_meta(pos)
+	local network=industrialtest.api.createNetworkMap(pos,false,omit)
+	meta:set_string("industrialtest.network",minetest.serialize(network))
+end
+
+-- \brief Returns true if meta contains network map, false otherwise
+-- \param meta MetaDataRef
+-- \returns bool
+industrialtest.api.isNetworkMaster=function(meta)
+	return meta:contains("industrialtest.network")
+end
+
+-- \brief Returns network table if node containing meta belongs to any networks, false otherwise
+-- \param meta MetaDataRef
+-- \returns bool or table
+industrialtest.api.isAttachedToNetwork=function(meta)
+	if not meta:contains("industrialtest.networks") then
+		return false
+	end
+	local networks=minetest.deserialize(meta:get_string("industrialtest.networks"))
+	if #networks==0 then
+		return false
+	end
+	return networks
+end
+
+-- \brief Returns network master network from it's meta, if meta doesn't contain network map then function returns false
+-- \param meta MetaDataRef
+-- \returns table or bool
+industrialtest.api.getNetwork=function(meta)
+	if not meta:contains("industrialtest.network") then
+		return false
+	end
+	return minetest.deserialize(meta:get_string("industrialtest.network"))
+end
+
+-- \brief Returns opposite side of provided one
+-- \param side Side number. See industrialtest.api.addPowerStorage for order
+-- \returns Opposite side
+industrialtest.api.getOppositeSide=function(side)
+	return (side%2==0 and side-1 or side+1)
+end
+-- \brief Returns connections of node with power storage. If direction is "i" only input connections will be returned, if direction is "o" only output connections
+--        will be returned, if it's not provided all connections will be returned.
+-- \param pos Vector
+-- \param (optional) direction string
+-- \returns table
+industrialtest.api.getConnections=function(pos,direction)
+	local result={}
+	local neighbourPositions={
+		vector.offset(pos,-1,0,0),
+		vector.offset(pos,1,0,0),
+		vector.offset(pos,0,-1,0),
+		vector.offset(pos,0,1,0),
+		vector.offset(pos,0,0,-1),
+		vector.offset(pos,0,0,1)
+	}
+	local sourceMeta=minetest.get_meta(pos)
+	local sourceDef=minetest.registered_nodes[minetest.get_node(pos).name]
+	local directionOutput=(not direction or direction=="o")
+	local directionInput=(not direction or direction=="i")
+	for key,conn in ipairs(neighbourPositions) do
+		local meta=minetest.get_meta(conn)
+		local def=minetest.registered_nodes[minetest.get_node(conn).name]
+		local normalizedKey=industrialtest.api.normalizeSide(pos,key)
+		local powerOutput=(sourceDef.groups._industrialtest_cable or industrialtest.api.isPowerOutput(sourceMeta,normalizedKey))
+		local powerInput=(sourceDef.groups._industrialtest_cable or industrialtest.api.isPowerInput(sourceMeta,normalizedKey))
+		if def.groups._industrialtest_cable or industrialtest.api.hasPowerStorage(meta) then
+			local side=industrialtest.api.normalizeSide(conn,industrialtest.api.getOppositeSide(normalizedKey))
+			if (powerOutput and directionInput and (def.groups._industrialtest_cable or industrialtest.api.isPowerInput(meta,side))) or ((def.groups._industrialtest_cable or industrialtest.api.isPowerOutput(meta,side)) and powerInput and directionOutput) then
+				table.insert(result,conn)
+			end
+		end
+	end
+	return result
+end
+-- \brief Changes node's power IO config. Function doesn't check if meta actually contains power storage.
+-- \param meta MetaDataRef of node which power IO config should be changed
+-- \param side Side number. See industrialtest.api.addPowerStorage to check order.
+-- \param mode Side mode. See industrialtest.api.addPowerStorage for possible values.
+-- \returns nil
+industrialtest.api.changeIoConfig=function(meta,side,mode)
+	local ioConfig=meta:get_string("industrialtest.ioConfig")
+	ioConfig=string.sub(ioConfig,1,side-1)..mode..string.sub(ioConfig,side+1)
+	meta:set_string("industrialtest.ioConfig",ioConfig)
+end
+-- \brief Checks if provided side is power input
+-- \param meta MetaDataRef of node
+-- \param side Side number. See industrialtest.api.addPowerStorage to check order.
+-- \returns true if provided side is power input, false otherwise
+industrialtest.api.isPowerInput=function(meta,side)
+	local ioConfig=meta:get_string("industrialtest.ioConfig")
+	local mode=string.sub(ioConfig,side,side)
+	return (mode=="i" or mode=="a")
+end
+-- \brief Checks if provided side is power output
+-- \param meta MetaDataRef of node
+-- \param side Side number. See industrialtest.api.addPowerStorage to check order.
+-- \returns true if provided side is power output, false otherwise
+industrialtest.api.isPowerOutput=function(meta,side)
+	local ioConfig=meta:get_string("industrialtest.ioConfig")
+	local mode=string.sub(ioConfig,side,side)
+	return (mode=="o" or mode=="a")
+end
+-- \brief Registers dust of certain resource
+-- \param name Technical name of resource
+-- \param displayName Display name of resource
+-- \param resources List of tables with following keys: <output>, <recipe>, [count(1)]
+--                                                      <> - required, [] - optional, () - default value
+-- \param color HTML color of dust
+-- \param registerMaceratorRecipe If true macerator recipe for dust will be registered
+-- \returns nil
+industrialtest.api.registerResourceDust=function(name,displayName,resources,color,registerMaceratorRecipe)
+	minetest.register_craftitem("industrialtest:"..name.."_dust",{
+		description=S(displayName.." Dust"),
+		inventory_image="industrialtest_dust.png",
+		color=color
+	})
+	if registerMaceratorRecipe then
+		for _,value in ipairs(resources) do
+			industrialtest.api.registerMaceratorRecipe({
+				output="industrialtest:"..name.."_dust "..(value.count or 1),
+				recipe=value.resource
+			})
+		end
+	end
+end
+-- \brief Registers plate of certain resource
+-- \param name Technical name of resource
+-- \param displayName Display name of resource
+-- \param resources List of tables with following keys: <output>, <recipe>, [count(1)]
+--                                                      <> - required, [] - optional, () - default value
+-- \param color HTML color of plate
+-- \param registerCompressorRecipe If true compressor recipe for plate will be registered
+-- \returns nil
+industrialtest.api.registerPlate=function(name,displayName,resources,color,registerCompressorRecipe)
+	minetest.register_craftitem("industrialtest:"..name,{
+		description=displayName,
+		inventory_image="industrialtest_plate.png",
+		color=color
+	})
+	if registerCompressorRecipe then
+		for _,value in ipairs(resources) do
+			industrialtest.api.registerCompressorRecipe({
+				output="industrialtest:"..name.." "..(value.count or 1),
+				recipe=value.resource
+			})
+		end
+	end
+end
+-- \brief Registers cell with certain fluid
+-- \param name Technical name of cell
+-- \param displayName Display name of cell
+-- \param node Node which can be picked up with this cell
+-- \returns nil
+industrialtest.api.registerStorageCell=function(name,displayName,node,modname)
+	if not modname then
+		modname="industrialtest"
+	end
+	minetest.register_craftitem("industrialtest:"..name.."_cell",{
+		description=S(displayName.." Cell"),
+		inventory_image=modname.."_"..name.."_cell.png",
+		on_place=function(itemstack,user,pointed)
+			if pointed.type~="node" or not user or not user:is_player() then
+				return nil
+			end
+			local node=minetest.get_node_or_nil(pointed.above)
+			local storage=industrialtest.api.getStorageCell("industrialtest:"..name.."_cell")
+			if storage.node then
+				if node.name~="air" and node.name~=storage.node then
+					return nil
+				end
+				minetest.set_node(pointed.above,{name=storage.node})
+				if itemstack:get_count()==1 then
+					itemstack:set_name("industrialtest:empty_cell")
+				else
+					local inv=user:get_inventory()
+					inv:add_item("main",ItemStack("industrialtest:empty_cell"))
+					itemstack:take_item()
+				end
+				return itemstack
+			end
+			return nil
+		end
+	})
+	industrialtest.api.storageCells["industrialtest:"..name.."_cell"]={
+		name="industrialtest:"..name.."_cell",
+		node=node
+	}
+end
+-- \brief Returns registred storage cell by name
+-- \param name Storage cell name
+-- \returns Table with following keys: name, node or nil in case of failure
+industrialtest.api.getStorageCell=function(name)
+	return industrialtest.api.storageCells[name]
+end
+-- \brief Returns registered storage cells by node
+-- \param node Node ID
+-- \returns Table with following keys: name, node or nil in case of failure
+industrialtest.api.getStorageCellByNode=function(node)
+	for _,value in pairs(industrialtest.api.storageCells) do
+		if value.node==node then
+			return value
+		end
+	end
+	return nil
+end
+-- \brief Registers macerator recipe
+-- \param config Table with keys: <output>, <recipe>, [time(2)]
+-- \returns nil
+industrialtest.api.registerMaceratorRecipe=function(config)
+	local definition={
+		output=config.output or "",
+		recipe=config.recipe or "",
+		time=config.time or 2
+	}
+	industrialtest.api.maceratorRecipes[definition.recipe]=definition
+end
+-- \brief Returns macerator recipe result
+-- \param recipe String ID of resulting conten
+-- \returns Table with following keys: output, recipe, time
+industrialtest.api.getMaceratorRecipeResult=function(recipe)
+	return industrialtest.api.maceratorRecipes[recipe]
+end
+-- \brief Registers compressor recipe
+-- \param config Table with following keys: <output>, <recipe>, [time(2)], [count(1)]
+-- \returns nil
+industrialtest.api.registerCompressorRecipe=function(config)
+	local definition={
+		output=config.output or "",
+		recipe=config.recipe or "",
+		time=config.time or 2,
+		count=config.count or 1
+	}
+	industrialtest.api.compressorRecipes[definition.recipe]=definition
+end
+-- \brief Returns macerator recipe result
+-- \param recipe String ID of resulting conten
+-- \returns Table with following keys: output, recipe, time
+industrialtest.api.getCompressorRecipeResult=function(recipe)
+	return industrialtest.api.compressorRecipes[recipe]
+end
+industrialtest.api.registerExtractorRecipe=function(config)
+	local definition={
+		output=config.output or "",
+		recipe=config.recipe or "",
+		time=config.time or 2
+	}
+	industrialtest.api.extractorRecipes[definition.recipe]=definition
+end
+industrialtest.api.getExtractorRecipeResult=function(recipe)
+	return industrialtest.api.extractorRecipes[recipe]
+end
+
+industrialtest.api.registerCableFormerRecipe=function(config)
+	local definition={
+		output=config.output or "",
+		recipe=config.recipe or "",
+		time=config.time or 2
+	}
+	industrialtest.api.cableFormerRecipes[definition.recipe]=definition
+end
+
+industrialtest.api.getCableFormerRecipeResult=function(recipe)
+	return industrialtest.api.cableFormerRecipes[recipe]
+end
+
+-- \brief Registers fuel that can be used in geothermal generator
+-- \param fuel Table with following keys: <name>, <calorificValue>, <storageItems>
+--        which is a table containing items which are tables with following keys: <name>, <leftover>
+-- \returns nil
+industrialtest.api.registerGeothermalGeneratorFuel=function(config)
+	local definition={
+		name=config.name or "",
+		calorificValue=config.calorificValue or 0,
+		texture=config.texture or "industrialtest_gui_fluid_bg.png",
+		storageItems=config.storageItems or {}
+	}
+	industrialtest.api.geothermalGeneratorFuels[definition.name]=definition
+end
+-- \brief Returns generator fuel information
+-- \param name Name of fuel
+-- \returns Table with following keys: name, calorificValue, storageItems
+industrialtest.api.getGeothermalGeneratorFuel=function(name)
+	return industrialtest.api.geothermalGeneratorFuels[name]
+end
+-- \brief Returns generator fuel information by item name
+-- \param name ID of item
+-- \returns Table with following keys: name, calorificValue, storageItems or nil in case of failure
+industrialtest.api.getGeothermalGeneratorFuelByItem=function(name)
+	for _,value in pairs(industrialtest.api.geothermalGeneratorFuels) do
+		for _,item in ipairs(value.storageItems) do
+			if item.name==name then
+				return value
+			end
+		end
+	end
+	return nil
+end
+-- \brief Registers fuel that can be used in water mill
+-- \param fuel Table with following keys: <name>, <calorificValue>, <storageItems>
+--        which is a table containing items which are tables with following keys: <name>, <leftover>
+-- \returns nil
+industrialtest.api.registerWaterMillFuel=function(config)
+	local definition={
+		name=config.name or "",
+		calorificValue=config.calorificValue or 0,
+		texture=config.texture or "industrialtest_gui_fluid_bg.png",
+		storageItems=config.storageItems or {}
+	}
+	industrialtest.api.waterMillFuels[definition.name]=definition
+end
+-- \brief Returns water mill fuel information
+-- \param name Name of fuel
+-- \returns Table with following keys: name, calorificValue, storageItems
+industrialtest.api.getWaterMillFuel=function(name)
+	return industrialtest.api.waterMillFuels[name]
+end
+-- \brief Returns water mill fuel information by item name
+-- \param name ID of item
+-- \returns Table with following keys: name, calorificValue, storageItems or nil in case of failure
+industrialtest.api.getWaterMillFuelByItem=function(name)
+	for _,value in pairs(industrialtest.api.waterMillFuels) do
+		for _,item in ipairs(value.storageItems) do
+			if item.name==name then
+				return value
+			end
+		end
+	end
+	return nil
+end
+
+-- \brief Registers Rotary Macerator recipe modifier
+-- \param config table
+-- \returns nil
+industrialtest.api.registerRotaryMaceratorModifier=function(config)
+	local definition={
+		name=config.name or "",
+		modifier=config.modifier or "",
+		output=config.output or "",
+		time=config.time or 2,
+		uses=config.uses or 1,
+		modifierLeftover=config.modifierLeftover
+	}
+	industrialtest.api.rotaryMaceratorModifiers[definition.name.." "..config.modifier]=definition
+end
+
+-- \brief Returns modified Rotary Macerator recipe by item and modifier
+-- \param name string
+-- \param modifier string
+-- \returns table
+industrialtest.api.getRotaryMaceratorModifier=function(name,modifier)
+	return industrialtest.api.rotaryMaceratorModifiers[name.." "..modifier]
+end
+
+-- \brief Returns machine speed in items per operation
+-- \param meta MetaDataRef
+-- \returns number
+industrialtest.api.getMachineSpeed=function(meta)
+	return meta:contains("industrialtest.speed") and meta:get_int("industrialtest.speed") or 1
+end

api/common.lua

@@ -1,50 +0,0 @@
--- IndustrialTest
--- Copyright (C) 2024 mrkubax10
-
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
-
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
-
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-industrialtest.api={
-	maceratorRecipes={},
-	compressorRecipes={},
-	extractorRecipes={},
-	cableFormerRecipes={},
-	geothermalGeneratorFuels={},
-	waterMillFuels={},
-	rotaryMaceratorModifiers={},
-	storageCells={},
-	tags={}
-}
-
-industrialtest.api.lvPowerFlow=600
-industrialtest.api.mvPowerFlow=2400
-industrialtest.api.hvPowerFlow=10200
-industrialtest.api.evPowerFlow=40800
-industrialtest.api.ivPowerFlow=163800
-
-function industrialtest.internal.clamp(num,min,max)
-	return math.max(math.min(num,max),min)
-end
-
-function industrialtest.internal.unpackTableInto(first,second)
-	for k,v in pairs(second) do
-		first[k]=v
-	end
-end
-
--- \brief Returns machine speed in items per operation
--- \param meta MetaDataRef
--- \returns number
-function industrialtest.api.getMachineSpeed(meta)
-	return meta:contains("industrialtest.speed") and meta:get_int("industrialtest.speed") or 1
-end

api/fluid.lua

@@ -1,132 +0,0 @@
--- IndustrialTest
--- Copyright (C) 2024 mrkubax10
-
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
-
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
-
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-local S=minetest.get_translator("industrialtest")
-
-local function createItemFluidStorageText(itemstack)
-	local meta=itemstack:get_meta()
-	local fluidCapacity=meta:get_int("industrialtest.fluidCapacity")
-	local fluidAmount=meta:get_int("industrialtest.fluidAmount")
-	local lowerLimit=math.floor(fluidCapacity*0.25)
-	local color=(fluidAmount>lowerLimit and "#0000FF" or "#FF0000")
-	return minetest.colorize(color,S("@1 / @2 mB",fluidAmount,fluidCapacity))
-end
-
--- \brief Check if itemstack contains fluid storage
--- \param itemstack ItemStack
--- \returns bool
-function industrialtest.api.itemHasFluidStorage(itemstack)
-	local values={"industrialtest.fluidAmount","industrialtest.fluidCapacity"}
-	local meta=itemstack:get_meta()
-	for _,value in ipairs(values) do
-		if not meta:contains(value) then
-			return false
-		end
-	end
-	return true
-end
-
--- \brief Check if fluid storage in meta is full
--- \param meta MetaDataRef
--- \returns bool
-function industrialtest.api.isFluidStorageFull(meta)
-	return meta:get_int("industrialtest.fluidAmount")>=meta:get_int("industrialtest.fluidCapacity")
-end
-
--- \brief Check if item fluid storage is full
--- \param itemstack ItemStack
--- \returns bool
-function industrialtest.api.isItemFluidStorageFull(itemstack)
-	local meta=itemstack:get_meta()
-	return industrialtest.api.isFluidStorageFull(meta)
-end
-
--- \brief Check if fluid storage in meta is empty
--- \param meta MetaDataRef
--- \returns bool
-function industrialtest.api.isFluidStorageEmpty(meta)
-	return meta:get_int("industrialtest.fluidAmount")==0
-end
-
--- \brief Check if item fluid storage is empty
--- \param itemstack ItemStack
--- \returns bool
-function industrialtest.api.isItemFluidStorageEmpty(itemstack)
-	local meta=itemstack:get_meta()
-	return industrialtest.api.isFluidStorageEmpty(meta)
-end
-
--- \brief Updates itemstack description and wear depending on contained fluid
--- \param itemstack ItemStack
--- \returns nil
-function industrialtest.api.updateItemFluidText(itemstack)
-	local meta=itemstack:get_meta()
-	if industrialtest.mtgAvailable then
-		local def=itemstack:get_definition()
-		local fluidStorageText=createItemFluidStorageText(itemstack)
-		meta:set_string("description",string.format("%s\n%s",def.description,fluidStorageText))
-	elseif industrialtest.mclAvailable then
-		tt.reload_itemstack_description(itemstack)
-	end
-	itemstack:set_wear(65535-meta:get_int("industrialtest.fluidAmount")/meta:get_int("industrialtest.fluidCapacity")*65534)
-end
-
--- \brief Adds fluid amount to item fluid storage
--- \param itemstack ItemStack
--- \param amount number
--- \returns number
-function industrialtest.api.addFluidToItem(itemstack,amount)
-	local meta=itemstack:get_meta()
-	if not industrialtest.api.itemHasFluidStorage(itemstack) then
-		return 0
-	end
-	local fluidAmount=meta:get_int("industrialtest.fluidAmount")
-	local fluidCapacity=meta:get_int("industrialtest.fluidCapacity")
-	local prevFluidAmount=fluidAmount
-	fluidAmount=industrialtest.internal.clamp(fluidAmount+amount,0,fluidCapacity)
-	meta:set_int("industrialtest.fluidAmount",fluidAmount)
-	industrialtest.api.updateItemFluidText(itemstack)
-	return fluidAmount-prevFluidAmount
-end
-
--- \brief Adds fluid to destination itemstack while subtracting it from source itemstack's metadata
--- \param srcItemstack ItemStack
--- \param itemstack ItemStack
--- \param amount number
--- \returns number
-function industrialtest.api.transferFluidToItem(srcItemstack,itemstack,amount)
-	local meta=srcItemstack:get_meta()
-	local flow=math.min(meta:get_int("industrialtest.fluidAmount"),amount)
-	if flow==0 then
-		return 0
-	end
-	local actualFlow=industrialtest.api.addFluidToItem(itemstack,flow)
-	meta:set_int("industrialtest.fluidAmount",meta:get_int("industrialtest.fluidAmount")-actualFlow)
-	industrialtest.api.updateItemFluidText(srcItemstack)
-	return actualFlow
-end
-
-if industrialtest.mclAvailable then
-	tt.register_snippet(function(itemstring,toolCapabilities,itemstack)
-		if not itemstack then
-			return nil
-		end
-		if not industrialtest.api.itemHasFluidStorage(itemstack) then
-			return nil
-		end
-		return createItemFluidStorageText(itemstack),false
-	end)
-end

api/network.lua

@@ -1,460 +0,0 @@
--- IndustrialTest
--- Copyright (C) 2024 mrkubax10
-
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
-
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
-
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-local function addNodeToNetwork(pos,networkMasterPos)
-	local meta=minetest.get_meta(pos)
-	local networks={}
-	if meta:contains("industrialtest.networks") then
-		networks=minetest.deserialize(meta:get_string("industrialtest.networks"))
-	end
-	for _,network in ipairs(networks) do
-		if network.x==networkMasterPos.x and network.y==networkMasterPos.y and network.z==networkMasterPos.z then
-			return
-		end
-	end
-	table.insert(networks,networkMasterPos)
-	meta:set_string("industrialtest.networks",minetest.serialize(networks))
-end
-
-local function clampFlow(pos,flow)
-	local def=minetest.registered_nodes[minetest.get_node(pos).name]
-	local newFlow
-	if def.groups and def.groups._industrialtest_cable then
-		newFlow=def._industrialtest_cableFlow
-	else
-		local meta=minetest.get_meta(pos)
-		newFlow=meta:get_int("industrialtest.powerFlow")
-	end
-	return math.min(flow,newFlow)
-end
-
--- \brief Finds path from pos to dest in network. Function finished if either dest is found or every node was visited
--- \param pos Vector
--- \param dest Vector
--- \returns table or nil
-function industrialtest.api.findPathInNetwork(pos,dest)
-	local connections=industrialtest.api.getConnections(pos,"i")
-	if #connections==0 then
-		return nil
-	end
-
-	local workers={}
-	local serializedSourcePos=pos.x..","..pos.y..","..pos.z
-	local visitedNodes={[serializedSourcePos]=true}
-	for _,conn in ipairs(connections) do
-		local sideVector=vector.subtract(conn,pos)
-		table.insert(workers,{
-			position=conn,
-			direction=sideVector,
-			path={[1]=conn}
-		})
-	end
-
-	while #workers>0 do
-		for i=1,#workers do
-			local worker=workers[i]
-			local serializedPos=worker.position.x..","..worker.position.y..","..worker.position.z
-			if visitedNodes[serializedPos] then
-				table.remove(workers,i)
-				break
-			end
-			visitedNodes[serializedPos]=true
-
-			if worker.position.x==dest.x and worker.position.y==dest.y and worker.position.z==dest.z then
-				return worker.path
-			end
-
-			local def=minetest.registered_nodes[minetest.get_node(worker.position).name]
-			if def and def.groups and def.groups._industrialtest_cable then
-				connections=industrialtest.api.getConnections(worker.position,"i")
-				for j=1,#connections do
-					local direction=vector.subtract(connections[j],worker.position)
-					local oppositeDirection=vector.multiply(worker.direction,vector.new(-1,-1,-1))
-					if direction.x~=oppositeDirection.x or direction.y~=oppositeDirection.y or direction.z~=oppositeDirection.z then
-						if worker.direction.x~=direction.x or worker.direction.y~=direction.y or worker.direction.z~=direction.z then
-							table.insert(worker.path,worker.position)
-						end
-						for c=1,#connections do
-							local nextDirection=vector.subtract(connections[c],worker.position)
-							if c~=j and (nextDirection.x~=oppositeDirection.x or nextDirection.y~=oppositeDirection.y or nextDirection.z~=oppositeDirection.z) then
-								local newWorker={
-									position=connections[c],
-									direction=nextDirection,
-									path=table.copy(worker.path)
-								}
-								table.insert(newWorker.path,worker.position)
-								table.insert(workers,newWorker)
-							end
-						end
-						worker.direction=direction
-						worker.position=connections[j]
-						break
-					end
-				end
-
-				if #connections>2 then
-					break
-				end
-			else
-				table.remove(workers,i)
-				break
-			end
-		end
-	end
-
-	return nil
-end
-
--- \brief Goes through path vertices specified by path running callback on each node.
---        Function finishes if either callback returns false or entire path is went over.
--- \param path table
--- \param callback function
--- \returns nil
-function industrialtest.api.walkPath(path,callback)
-	local pos=path[1]
-	for i=2,#path do
-		local pathNode=path[i]
-		local direction=vector.normalize(vector.subtract(pathNode,pos))
-		while pos.x~=pathNode.x or pos.y~=pathNode.y or pos.z~=pathNode.z do
-			if not callback(pos) then
-				return
-			end
-			pos=vector.add(pos,direction)
-		end
-	end
-end
-
--- \brief Transfers power from source node to it's network, if sides is set then power will be only transfered to network connected to that sides
--- \param pos Vector with position of source node
--- \param (optional) sides table with Vectors
--- \param (optional) flowOverride number
--- \returns two values: true if any neighbouring node has room for more power, false otherwise
---                      true if any power was transferred, false otherwise
-function industrialtest.api.powerFlow(pos,sides,flowOverride)
-	local meta=minetest.get_meta(pos)
-	-- if machine doesn't have network map then it's not capable of transferring power
-	local network=industrialtest.api.getNetwork(meta)
-	if not network or #network==0 then
-		return false,false
-	end
-	local endpointCount=0
-	for _,endpoint in ipairs(network) do
-		local endpointMeta=minetest.get_meta(endpoint.position)
-		if not industrialtest.api.isFullyCharged(endpointMeta) and (not sides or sides[endpoint.sourceSide]) then
-			endpointCount=endpointCount+1
-		end
-	end
-	if endpointCount==0 then
-		return false,false
-	end
-
-	local ioConfig=industrialtest.api.getIoConfig(meta)
-	local transferred=false
-	local roomAvailable=false
-	for _,endpoint in ipairs(network) do
-		if not sides or sides[endpoint.sourceSide] then
-			local flow
-			if flowOverride then
-				flow=flowOverride
-			elseif type(ioConfig)=="string" then
-				flow=math.min(meta:get_int("industrialtest.powerAmount"),meta:get_int("industrialtest.powerFlow"))
-			else
-				flow=math.min(meta:get_int("industrialtest.powerAmount"),ioConfig[endpoint.sourceSide].flow)
-			end
-			local powerDistribution=math.floor(flow/endpointCount)
-			local endpointMeta=minetest.get_meta(endpoint.position)
-			if powerDistribution<=endpoint.flow then
-				local transferredPower=industrialtest.api.transferPower(meta,endpointMeta,powerDistribution)
-				if transferredPower>0 then
-					transferred=true
-				end
-				local def=minetest.registered_nodes[minetest.get_node(endpoint.position).name]
-				if def and def._industrialtest_self then
-					def._industrialtest_self:updateFormspec(endpoint.position)
-					if def._industrialtest_self.onPowerFlow and transferredPower>0 then
-						def._industrialtest_self:onPowerFlow(endpoint.position,industrialtest.api.getOppositeSide(endpoint.side),transferredPower)
-					end
-					def._industrialtest_self:triggerIfNeeded(endpoint.position)
-				else
-					-- Support for bare definitions that don't use industrialtest pseudo-OOP
-					minetest.get_node_timer(endpoint.position):start(industrialtest.config.updateDelay)
-				end
-				if not industrialtest.api.isFullyCharged(endpointMeta) then
-					roomAvailable=true
-				end
-			else
-				local path=industrialtest.api.findPathInNetwork(pos,endpoint.position)
-				if path and #path>0 then
-					table.insert(path,endpoint.position)
-					local removed=false
-					industrialtest.api.walkPath(path,function(pathPos)
-						local def=minetest.registered_nodes[minetest.get_node(pathPos).name]
-						if not def or not def.groups or not def.groups._industrialtest_cable then
-							return false
-						end
-						if powerDistribution>def._industrialtest_cableFlow then
-							removed=true
-							minetest.swap_node(pathPos,{
-								name="air"
-							})
-							minetest.remove_node(pathPos)
-							minetest.check_for_falling(pathPos)
-							minetest.sound_play("default_cool_lava",{
-								pos=pathPos,
-								max_hear_distance=5,
-								gain=0.7
-							})
-						end
-						return true
-					end)
-					if not removed and powerDistribution>endpoint.originalFlow then
-						minetest.remove_node(endpoint.position)
-						industrialtest.internal.explode(endpoint.position,2)
-					end
-					industrialtest.api.createNetworkMapForNode(pos)
-				end
-			end
-		end
-	end
-	return roomAvailable,transferred
-end
-
--- \brief Creates network map starting from node at pos, optionally omitting node at omit
--- \param pos vector
--- \param (optional) addCables bool
--- \param (optional) omit Vector
--- \returns table with network map
-function industrialtest.api.createNetworkMap(pos,addCables,omit)
-	local map={}
-	local connections=industrialtest.api.getConnections(pos,"i")
-	if #connections==0 then
-		return map
-	end
-
-	local sourceMeta=minetest.get_meta(pos)
-	local workers={}
-	local sides={
-		["-1,0,0"]=1,
-		["1,0,0"]=2,
-		["0,-1,0"]=3,
-		["0,1,0"]=4,
-		["0,0,-1"]=5,
-		["0,0,1"]=6
-	}
-	local serializedSourcePos=pos.x..","..pos.y..","..pos.z
-	local visitedNodes={[serializedSourcePos]=true}
-	for _,conn in ipairs(connections) do
-		if not omit or conn.x~=omit.x or conn.y~=omit.y or conn.z~=omit.z then
-			local sideVector=vector.subtract(conn,pos)
-			local serializedSideVector=sideVector.x..","..sideVector.y..","..sideVector.z
-			local sourceSide=industrialtest.api.normalizeSide(pos,sides[serializedSideVector])
-			table.insert(workers,{
-				position=conn,
-				direction=sideVector,
-				distance=1,
-				flow=industrialtest.api.getPowerFlowForSide(sourceMeta,sourceSide),
-				sourceSide=sourceSide
-			})
-		end
-	end
-
-	while #workers>0 do
-		for i=1,#workers do
-			local worker=workers[i]
-			local serializedPos=worker.position.x..","..worker.position.y..","..worker.position.z
-			if visitedNodes[serializedPos] or (omit and omit==worker.position) then
-				table.remove(workers,i)
-				break
-			end
-			visitedNodes[serializedPos]=true
-			addNodeToNetwork(worker.position,pos)
-
-			local def=minetest.registered_nodes[minetest.get_node(worker.position).name]
-			if def and def.groups and def.groups._industrialtest_cable then
-				if addCables then
-					table.insert(map,{
-						position=worker.position,
-						distance=worker.distance,
-						flow=clampFlow(worker.position,worker.flow),
-						side=0,
-						sourceSide=worker.sourceSide
-					})
-				end
-				connections=industrialtest.api.getConnections(worker.position,"i")
-				if #connections==0 then
-					table.remove(workers,i)
-					break
-				end
-				worker.flow=clampFlow(worker.position,worker.flow)
-				worker.distance=worker.distance+1
-				for i=2,#connections do
-					table.insert(workers,{
-						position=connections[i],
-						direction=vector.subtract(connections[i],worker.position),
-						distance=worker.distance,
-						flow=worker.flow,
-						sourceSide=worker.sourceSide
-					})
-				end
-				worker.direction=vector.subtract(connections[1],worker.position)
-				worker.position=connections[1]
-				if #connections>=2 then
-					break
-				end
-			else
-				local meta=minetest.get_meta(worker.position)
-				local incomingSide=industrialtest.api.normalizeSide(worker.position,sides[worker.direction.x..","..worker.direction.y..","..worker.direction.z])
-				local connectionSide=industrialtest.api.getOppositeSide(incomingSide)
-				local flow=industrialtest.api.getPowerFlowForSide(meta,connectionSide)
-				table.insert(map,{
-					position=worker.position,
-					distance=worker.distance,
-					flow=math.min(worker.flow,flow),
-					originalFlow=flow,
-					side=connectionSide,
-					sourceSide=worker.sourceSide
-				})
-				table.remove(workers,i)
-				break
-			end
-		end
-	end
-
-	return map
-end
-
-function industrialtest.api.removeNodeFromNetwork(pos,nodePos)
-	local meta=minetest.get_meta(pos)
-	if not meta:contains("industrialtest.network") then
-		return
-	end
-	local network=minetest.deserialize(meta:get_string("industrialtest.network"))
-	local removed=false
-	for key,node in ipairs(network) do
-		if node.position.x==nodePos.x and node.position.y==nodePos.y and node.position.z==nodePos.z then
-			table.remove(network,key)
-			removed=true
-			break
-		end
-	end
-	if removed then
-		meta:set_string("industrialtest.network",minetest.serialize(network))
-	end
-end
-
--- \brief Creates network map and writes it to node metadata at pos, optionally omitting node at omit
--- \param pos Vector
--- \param (optional) omit Vector
--- \returns nil
-function industrialtest.api.createNetworkMapForNode(pos,omit)
-	local meta=minetest.get_meta(pos)
-	local network=industrialtest.api.createNetworkMap(pos,false,omit)
-	meta:set_string("industrialtest.network",minetest.serialize(network))
-end
-
--- \brief Returns true if meta contains network map, false otherwise
--- \param meta MetaDataRef
--- \returns bool
-function industrialtest.api.isNetworkMaster(meta)
-	return meta:contains("industrialtest.network")
-end
-
--- \brief Returns network table if node containing meta belongs to any networks, false otherwise
--- \param meta MetaDataRef
--- \returns bool or table
-function industrialtest.api.isAttachedToNetwork(meta)
-	if not meta:contains("industrialtest.networks") then
-		return false
-	end
-	local networks=minetest.deserialize(meta:get_string("industrialtest.networks"))
-	if #networks==0 then
-		return false
-	end
-	return networks
-end
-
--- \brief Returns network master network from it's meta, if meta doesn't contain network map then function returns false
--- \param meta MetaDataRef
--- \returns table or bool
-function industrialtest.api.getNetwork(meta)
-	if not meta:contains("industrialtest.network") then
-		return false
-	end
-	return minetest.deserialize(meta:get_string("industrialtest.network"))
-end
-
--- \brief Returns amount of power that will flow from specified network master
--- \param pos Vector
--- \returns number
-function industrialtest.api.getFlowingCurrent(pos)
-	local meta=minetest.get_meta(pos)
-	if not industrialtest.api.hasPowerStorage(meta) or meta:get_int("industrialtest.powerAmount")==0 then
-		return 0
-	end
-	local network=industrialtest.api.getNetwork(meta)
-	if not network then
-		return 0
-	end
-
-	local amount=meta:get_int("industrialtest.powerAmount")
-	if amount==0 then
-		return 0
-	end
-	local demand=0
-	for _,endpoint in ipairs(network) do
-		local endpointMeta=minetest.get_meta(endpoint.position)
-		if industrialtest.api.hasPowerStorage(endpointMeta) then
-			demand=demand+math.min(endpointMeta:get_int("industrialtest.powerCapacity")-endpointMeta:get_int("industrialtest.powerAmount"),endpoint.flow)
-		end
-	end
-
-	return math.min(amount,demand)
-end
-
--- \brief Returns connections of node with power storage. If direction is "i" only input connections will be returned, if direction is "o" only output connections
---        will be returned, if it's not provided all connections will be returned.
--- \param pos Vector
--- \param (optional) direction string
--- \returns table
-function industrialtest.api.getConnections(pos,direction)
-	local result={}
-	local neighbourPositions={
-		vector.offset(pos,-1,0,0),
-		vector.offset(pos,1,0,0),
-		vector.offset(pos,0,-1,0),
-		vector.offset(pos,0,1,0),
-		vector.offset(pos,0,0,-1),
-		vector.offset(pos,0,0,1)
-	}
-	local sourceMeta=minetest.get_meta(pos)
-	local sourceDef=minetest.registered_nodes[minetest.get_node(pos).name]
-	local directionOutput=(not direction or direction=="o")
-	local directionInput=(not direction or direction=="i")
-	for key,conn in ipairs(neighbourPositions) do
-		local meta=minetest.get_meta(conn)
-		local def=minetest.registered_nodes[minetest.get_node(conn).name]
-		local normalizedKey=industrialtest.api.normalizeSide(pos,key)
-		local powerOutput=(sourceDef.groups._industrialtest_cable or industrialtest.api.isPowerOutput(sourceMeta,normalizedKey))
-		local powerInput=(sourceDef.groups._industrialtest_cable or industrialtest.api.isPowerInput(sourceMeta,normalizedKey))
-		if def.groups._industrialtest_cable or industrialtest.api.hasPowerStorage(meta) then
-			local side=industrialtest.api.normalizeSide(conn,industrialtest.api.getOppositeSide(key))
-			if (powerOutput and directionInput and (def.groups._industrialtest_cable or industrialtest.api.isPowerInput(meta,side))) or ((def.groups._industrialtest_cable or industrialtest.api.isPowerOutput(meta,side)) and powerInput and directionOutput) then
-				table.insert(result,conn)
-			end
-		end
-	end
-	return result
-end

api/power.lua

@@ -1,237 +0,0 @@
--- IndustrialTest
--- Copyright (C) 2024 mrkubax10
-
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
-
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
-
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-local S=minetest.get_translator("industrialtest")
-
-local function createItemPowerText(itemstack)
-	local meta=itemstack:get_meta()
-	local powerCapacity=meta:get_int("industrialtest.powerCapacity")
-	local powerAmount=meta:get_int("industrialtest.powerAmount")
-	local lowerLimit=math.floor(powerCapacity*0.25)
-	local color=(powerAmount>lowerLimit and "#00FFFF" or "#FF0000")
-	return minetest.colorize(color,S("@1 / @2 EU",powerAmount,powerCapacity))
-end
-
--- \brief Adds power storage to metadata
--- \param capacity How much EU item/node can store
--- \param flow How much EU can flow in or out item/node per industrialtest.updateDelay
--- \param ioConfig Input/Output configuration in following side order: -X, +X, -Y, +Y, -Z, +Z
---                 a - bidirectional, i - input, o - output.
---                 Instead of string containing IO mode for each side, ioConfig can hold a table for each side, containing
---                 IO mode and flow override
--- \returns nil
-function industrialtest.api.addPowerStorage(meta,capacity,flow,ioConfig)
-	meta:set_int("industrialtest.powerCapacity",capacity)
-	meta:set_int("industrialtest.powerFlow",flow)
-	meta:set_int("industrialtest.powerAmount",0)
-	meta:set_int("industrialtest.extendedIoConfig",type(ioConfig)~="string" and 1 or 0)
-	meta:set_string("industrialtest.ioConfig",type(ioConfig)=="string" and ioConfig or minetest.serialize(ioConfig))
-end
-
--- \brief Checks if metadata contains power storage
--- \param meta MetaDataRef which should be checked
--- \returns true if metadata contains power storage, false otherwise
-function industrialtest.api.hasPowerStorage(meta)
-	local values={"industrialtest.powerCapacity","industrialtest.powerFlow","industrialtest.powerAmount","industrialtest.ioConfig"}
-	for _,value in ipairs(values) do
-		if not meta:contains(value) then
-			return false
-		end
-	end
-	return true
-end
-
--- \brief Checks if ioConfig from metadata is extended one. It exploits the fact that minetest.serialize returns Lua code
---        which returns table, hence it can check for return at the beginning of the string
--- \param meta MetaDataRef
--- \returns bool
-function industrialtest.api.isExtendedIoConfig(meta)
-	return meta:get_int("industrialtest.extendedIoConfig")==1
-end
-
--- \brief Returns ioConfig from metadata, deserializing it if it's extended one
--- \param meta MetaDataRef
--- \returns table or string
-function industrialtest.api.getIoConfig(meta)
-	local ioConfig=meta:get_string("industrialtest.ioConfig")
-	return industrialtest.api.isExtendedIoConfig(meta) and minetest.deserialize(ioConfig) or ioConfig
-end
-
--- \brief Changes node's power IO config. Function doesn't check if meta actually contains power storage.
--- \param meta MetaDataRef of node which power IO config should be changed
--- \param side Side number. See industrialtest.api.addPowerStorage to check order.
--- \param mode Side mode. See industrialtest.api.addPowerStorage for possible values.
--- \returns nil
-function industrialtest.api.changeIoConfig(meta,side,mode)
-	local ioConfig=industrialtest.api.getIoConfig(meta)
-	if type(ioConfig)=="string" then
-		ioConfig=string.sub(ioConfig,1,side-1)..mode..string.sub(ioConfig,side+1)
-		meta:set_string("industrialtest.ioConfig",ioConfig)
-	else
-		ioConfig[side]=mode
-		meta:set_string("industrialtest.ioConfig",minetest.serialize(ioConfig))
-	end
-end
-
--- \brief Returns power flow for side
--- \param meta MetaDataRef
--- \param side number Side number
--- \returns number
-function industrialtest.api.getPowerFlowForSide(meta,side)
-	local ioConfig=industrialtest.api.getIoConfig(meta)
-	if type(ioConfig)=="string" then
-		return meta:get_int("industrialtest.powerFlow")
-	else
-		return ioConfig[side].flow
-	end
-end
-
--- \brief Checks if provided side is power input
--- \param meta MetaDataRef of node
--- \param side Side number. See industrialtest.api.addPowerStorage to check order.
--- \returns true if provided side is power input, false otherwise
-function industrialtest.api.isPowerInput(meta,side)
-	local ioConfig=industrialtest.api.getIoConfig(meta)
-	if type(ioConfig)=="string" then
-		local mode=string.sub(ioConfig,side,side)
-		return (mode=="i" or mode=="a")
-	else
-		return (ioConfig[side].mode=="i" or ioConfig[side].mode=="a")
-	end
-end
-
--- \brief Checks if provided side is power output
--- \param meta MetaDataRef of node
--- \param side Side number. See industrialtest.api.addPowerStorage to check order.
--- \returns true if provided side is power output, false otherwise
-function industrialtest.api.isPowerOutput(meta,side)
-	local ioConfig=industrialtest.api.getIoConfig(meta)
-	if type(ioConfig)=="string" then
-		local mode=string.sub(ioConfig,side,side)
-		return (mode=="o" or mode=="a")
-	else
-		return (ioConfig[side].mode=="o" or ioConfig[side].mode=="a")
-	end
-end
-
--- \brief Checks if power storage is fully charged
--- \param meta MetaDataRef which should be checked
--- \returns true if power storage is fully charged, false otherwise
-function industrialtest.api.isFullyCharged(meta)
-	return meta:get_int("industrialtest.powerAmount")>=meta:get_int("industrialtest.powerCapacity")
-end
-
--- \brief Adds power to power storage. Function doesn't check if meta contains power storage so you must be sure that it does.
--- \param meta MetaDataRef to which power should be added
--- \param amount Amount of power to add
--- \returns How much of power was actually added
-function industrialtest.api.addPower(meta,amount)
-	local powerAmount=meta:get_int("industrialtest.powerAmount")
-	local powerCapacity=meta:get_int("industrialtest.powerCapacity")
-	local prevPowerAmount=powerAmount
-	powerAmount=industrialtest.internal.clamp(powerAmount+amount,0,powerCapacity)
-	meta:set_int("industrialtest.powerAmount",powerAmount)
-	return powerAmount-prevPowerAmount
-end
-
--- \brief Adds power to destination metadata while subtracting it from source metadata
--- \Param srcMeta MetaDataRef from which take power
--- \param destMeta MetaDataRef to which add power
--- \returns How much of power was actually transferred
-function industrialtest.api.transferPower(srcMeta,destMeta,amount)
-	local currentFlow=math.min(srcMeta:get_int("industrialtest.powerAmount"),amount)
-	if currentFlow==0 then
-		return 0
-	end
-	local actualFlow=industrialtest.api.addPower(destMeta,currentFlow)
-	srcMeta:set_int("industrialtest.powerAmount",srcMeta:get_int("industrialtest.powerAmount")-actualFlow)
-	return actualFlow
-end
-
--- \brief Updates itemstack description to show current power storage information, additionally updates item wear bar.
---        Function doesn't check if itemstack contains power storage so you should be sure that it does before calling this function
--- \param itemstack ItemStack which should be updated
--- \returns nil
-function industrialtest.api.updateItemPowerText(itemstack)
-	local meta=itemstack:get_meta()
-	if industrialtest.mtgAvailable then
-		local def=minetest.registered_tools[itemstack:get_name()]
-		local desc=meta:contains("industrialtest.descriptionOverride") and meta:get_string("industrialtest.descriptionOverride") or def.description
-		local powerText=createItemPowerText(itemstack)
-		meta:set_string("description",string.format("%s\n%s",desc,powerText))
-	elseif industrialtest.mclAvailable then
-		tt.reload_itemstack_description(itemstack)
-	end
-	itemstack:set_wear(65535-meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*65534)
-end
-
--- \brief Adds power to itemstack. Function checks if itemstack has power storage.
--- \param itemstack ItemStack to which add power
--- \param amount How much power to add
--- \returns Amount of power added
-function industrialtest.api.addPowerToItem(itemstack,amount)
-	local meta=itemstack:get_meta()
-	if not industrialtest.api.hasPowerStorage(meta) then
-		return 0
-	end
-	local added=industrialtest.api.addPower(meta,amount)
-	industrialtest.api.updateItemPowerText(itemstack)
-	return added
-end
-
--- \brief Adds power to destination itemstack while subtracting it from source metadata
--- \param srcMeta MetaDataRef from which take power
--- \param itemstack ItemStack to which add power
--- \param amount number
--- \returns How much of power was actually transferred
-function industrialtest.api.transferPowerToItem(srcMeta,itemstack,amount)
-	local currentFlow=math.min(srcMeta:get_int("industrialtest.powerAmount"),amount)
-	if currentFlow==0 then
-		return 0
-	end
-	local actualFlow=industrialtest.api.addPowerToItem(itemstack,currentFlow)
-	srcMeta:set_int("industrialtest.powerAmount",srcMeta:get_int("industrialtest.powerAmount")-actualFlow)
-	return actualFlow
-end
-
--- \brief Adds power to destination metadata while subtracting it from source itemstack
--- \param srcItemstack ItemStack from which subtract power
--- \param meta MetaDataRef to which add power
--- \param amount How much power should be transferred
--- \returns How much of power was actually transferred
-function industrialtest.api.transferPowerFromItem(srcItemstack,meta,amount)
-	local srcMeta=srcItemstack:get_meta()
-	local currentFlow=math.min(srcMeta:get_int("industrialtest.powerAmount"),amount)
-	if currentFlow==0 then
-		return 0
-	end
-	local actualFlow=industrialtest.api.addPower(meta,currentFlow)
-	industrialtest.api.addPowerToItem(srcItemstack,-actualFlow)
-	return actualFlow
-end
-
-if industrialtest.mclAvailable then
-	tt.register_snippet(function(itemstring,toolCapabilities,itemstack)
-		if not itemstack then
-			return nil
-		end
-		local meta=itemstack:get_meta()
-		if not industrialtest.api.hasPowerStorage(meta) then
-			return nil
-		end
-		return createItemPowerText(itemstack),false
-	end)
-end

api/registration.lua

@@ -1,323 +0,0 @@
--- IndustrialTest
--- Copyright (C) 2024 mrkubax10
-
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
-
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
-
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-local S=minetest.get_translator("industrialtest")
-
-function industrialtest.api.addTag(name,tag)
-	if not industrialtest.api.tags[tag] then
-		industrialtest.api.tags[tag]={}
-	end
-	table.insert(industrialtest.api.tags[tag],name)
-end
-
--- \brief Registers dust of certain resource
--- \param name Technical name of resource
--- \param displayName Display name of resource
--- \param resources List of tables with following keys: <output>, <recipe>, [count(1)]
---                                                      <> - required, [] - optional, () - default value
--- \param color HTML color of dust
--- \param registerMaceratorRecipe If true macerator recipe for dust will be registered
--- \returns nil
-function industrialtest.api.registerResourceDust(name,displayName,resources,color,registerMaceratorRecipe)
-	minetest.register_craftitem("industrialtest:"..name.."_dust",{
-		description=S(displayName.." Dust"),
-		inventory_image="industrialtest_dust.png",
-		color=color
-	})
-	if registerMaceratorRecipe then
-		for _,value in ipairs(resources) do
-			industrialtest.api.registerMaceratorRecipe({
-				output="industrialtest:"..name.."_dust "..(value.count or 1),
-				recipe=value.resource
-			})
-		end
-	end
-end
-
--- \brief Registers plate of certain resource
--- \param name Technical name of resource
--- \param displayName Display name of resource
--- \param resources List of tables with following keys: <output>, <recipe>, [count(1)]
---                                                      <> - required, [] - optional, () - default value
--- \param color HTML color of plate
--- \param registerCompressorRecipe If true compressor recipe for plate will be registered
--- \returns nil
-function industrialtest.api.registerPlate(name,displayName,resources,color,registerCompressorRecipe)
-	minetest.register_craftitem("industrialtest:"..name,{
-		description=displayName,
-		inventory_image="industrialtest_plate.png",
-		inventory_overlay="industrialtest_plate_overlay.png",
-		color=color
-	})
-	if registerCompressorRecipe then
-		for _,value in ipairs(resources) do
-			industrialtest.api.registerCompressorRecipe({
-				output="industrialtest:"..name.." "..(value.count or 1),
-				recipe=value.resource
-			})
-		end
-	end
-end
-
--- \brief Registers cell with certain fluid
--- \param name Technical name of cell
--- \param displayName Display name of cell
--- \param node Node which can be picked up with this cell
--- \returns nil
-function industrialtest.api.registerStorageCell(name,displayName,node,modname,color)
-	color = color or "#ffffffff"
-	if not modname then
-		modname="industrialtest"
-	end
-	minetest.register_craftitem("industrialtest:"..name.."_cell",{
-		description=S(displayName.." Cell"),
-		inventory_image="industrialtest_cell_fluid.png",
-		inventory_overlay="industrialtest_cell_casing.png",
-		color=color,
-		on_place=function(itemstack,user,pointed)
-			if pointed.type~="node" or not user or not user:is_player() then
-				return nil
-			end
-			local node=minetest.get_node_or_nil(pointed.above)
-			local storage=industrialtest.api.getStorageCell("industrialtest:"..name.."_cell")
-			if storage.node then
-				if node.name~="air" and node.name~=storage.node then
-					return nil
-				end
-				minetest.set_node(pointed.above,{name=storage.node})
-				if itemstack:get_count()==1 then
-					itemstack:set_name("industrialtest:empty_cell")
-				else
-					local inv=user:get_inventory()
-					inv:add_item("main",ItemStack("industrialtest:empty_cell"))
-					itemstack:take_item()
-				end
-				return itemstack
-			end
-			return nil
-		end
-	})
-	industrialtest.api.storageCells["industrialtest:"..name.."_cell"]={
-		name="industrialtest:"..name.."_cell",
-		node=node
-	}
-end
-
--- \brief Returns registred storage cell by name
--- \param name Storage cell name
--- \returns Table with following keys: name, node or nil in case of failure
-function industrialtest.api.getStorageCell(name)
-	return industrialtest.api.storageCells[name]
-end
-
--- \brief Returns registered storage cells by node
--- \param node Node ID
--- \returns Table with following keys: name, node or nil in case of failure
-function industrialtest.api.getStorageCellByNode(node)
-	for _,value in pairs(industrialtest.api.storageCells) do
-		if value.node==node then
-			return value
-		end
-	end
-	return nil
-end
-
--- \brief Registers macerator recipe
--- \param config Table with keys: <output>, <recipe>, [time(2)]
--- \returns nil
-function industrialtest.api.registerMaceratorRecipe(config)
-	local definition={
-		output=config.output or "",
-		recipe=config.recipe or "",
-		time=config.time or 2
-	}
-	industrialtest.api.maceratorRecipes[definition.recipe]=definition
-end
-
--- \brief Returns macerator recipe result
--- \param recipe String ID of resulting conten
--- \returns Table with following keys: output, recipe, time
-function industrialtest.api.getMaceratorRecipeResult(recipe)
-	return industrialtest.api.maceratorRecipes[recipe]
-end
-
--- \brief Registers compressor recipe
--- \param config Table with following keys: <output>, <recipe>, [time(2)], [count(1)]
--- \returns nil
-function industrialtest.api.registerCompressorRecipe(config)
-	local definition={
-		output=config.output or "",
-		recipe=config.recipe or "",
-		time=config.time or 2,
-		count=config.count or 1
-	}
-	industrialtest.api.compressorRecipes[definition.recipe]=definition
-end
-
--- \brief Returns macerator recipe result
--- \param recipe String ID of resulting conten
--- \returns Table with following keys: output, recipe, time
-function industrialtest.api.getCompressorRecipeResult(recipe)
-	return industrialtest.api.compressorRecipes[recipe]
-end
-
-function industrialtest.api.registerExtractorRecipe(config)
-	local definition={
-		output=config.output or "",
-		recipe=config.recipe or "",
-		time=config.time or 2
-	}
-	industrialtest.api.extractorRecipes[definition.recipe]=definition
-end
-
-function industrialtest.api.getExtractorRecipeResult(recipe)
-	return industrialtest.api.extractorRecipes[recipe]
-end
-
-function industrialtest.api.registerCableFormerRecipe(config)
-	local definition={
-		output=config.output or "",
-		recipe=config.recipe or "",
-		time=config.time or 2
-	}
-	industrialtest.api.cableFormerRecipes[definition.recipe]=definition
-end
-
-function industrialtest.api.getCableFormerRecipeResult(recipe)
-	return industrialtest.api.cableFormerRecipes[recipe]
-end
-
--- \brief Registers fuel that can be used in geothermal generator
--- \param fuel Table with following keys: <name>, <calorificValue>, <storageItems>
---        which is a table containing items which are tables with following keys: <name>, <leftover>
--- \returns nil
-function industrialtest.api.registerGeothermalGeneratorFuel(config)
-	local definition={
-		name=config.name or "",
-		calorificValue=config.calorificValue or 0,
-		texture=config.texture or "industrialtest_gui_fluid_bg.png",
-		storageItems=config.storageItems or {}
-	}
-	industrialtest.api.geothermalGeneratorFuels[definition.name]=definition
-end
-
--- \brief Returns generator fuel information
--- \param name Name of fuel
--- \returns Table with following keys: name, calorificValue, storageItems
-function industrialtest.api.getGeothermalGeneratorFuel(name)
-	return industrialtest.api.geothermalGeneratorFuels[name]
-end
-
--- \brief Returns generator fuel information by item name
--- \param name ID of item
--- \returns Table with following keys: name, calorificValue, storageItems or nil in case of failure
-function industrialtest.api.getGeothermalGeneratorFuelByItem(name)
-	for _,value in pairs(industrialtest.api.geothermalGeneratorFuels) do
-		for _,item in ipairs(value.storageItems) do
-			if item.name==name then
-				return value
-			end
-		end
-	end
-	return nil
-end
-
--- \brief Registers fuel that can be used in water mill
--- \param fuel Table with following keys: <name>, <calorificValue>, <storageItems>
---        which is a table containing items which are tables with following keys: <name>, <leftover>
--- \returns nil
-function industrialtest.api.registerWaterMillFuel(config)
-	local definition={
-		name=config.name or "",
-		calorificValue=config.calorificValue or 0,
-		texture=config.texture or "industrialtest_gui_fluid_bg.png",
-		storageItems=config.storageItems or {}
-	}
-	industrialtest.api.waterMillFuels[definition.name]=definition
-end
-
--- \brief Returns water mill fuel information
--- \param name Name of fuel
--- \returns Table with following keys: name, calorificValue, storageItems
-function industrialtest.api.getWaterMillFuel(name)
-	return industrialtest.api.waterMillFuels[name]
-end
-
--- \brief Returns water mill fuel information by item name
--- \param name ID of item
--- \returns Table with following keys: name, calorificValue, storageItems or nil in case of failure
-function industrialtest.api.getWaterMillFuelByItem(name)
-	for _,value in pairs(industrialtest.api.waterMillFuels) do
-		for _,item in ipairs(value.storageItems) do
-			if item.name==name then
-				return value
-			end
-		end
-	end
-	return nil
-end
-
--- \brief Registers Rotary Macerator recipe modifier
--- \param config table
--- \param omitPlaceholder bool, for internal use only
--- \returns nil
-function industrialtest.api.registerRotaryMaceratorModifier(config,omitPlaceholder)
-	local definition={
-		name=config.name or "",
-		modifier=config.modifier or "",
-		output=config.output or "",
-		time=config.time or 2,
-		uses=config.uses or 1,
-		modifierLeftover=config.modifierLeftover
-	}
-
-	if not omitPlaceholder and not config.modifierLeftover and string.len(definition.modifier)>0 then
-		local delimiter,_=string.find(definition.modifier,":")
-		definition.stackLeftover="industrialtest:"..string.sub(definition.modifier,1,delimiter-1).."_"..string.sub(definition.modifier,delimiter+1,-1).."_leftover"
-		industrialtest.api.registerRotaryMaceratorModifier({
-			name=definition.name,
-			modifier=definition.stackLeftover,
-			output=definition.output,
-			time=definition.time,
-			uses=definition.uses
-		},true)
-	end
-
-	industrialtest.api.rotaryMaceratorModifiers[definition.name.." "..config.modifier]=definition
-end
-
--- \brief Returns modified Rotary Macerator recipe by item and modifier
--- \param name string
--- \param modifier string
--- \returns table
-function industrialtest.api.getRotaryMaceratorModifier(name,modifier)
-	return industrialtest.api.rotaryMaceratorModifiers[name.." "..modifier]
-end
-
-minetest.register_on_mods_loaded(function()
-	for _,def in pairs(industrialtest.api.rotaryMaceratorModifiers) do
-		if def.stackLeftover then
-			local leftoverDef=table.copy(minetest.registered_items[def.modifier])
-			leftoverDef.groups=leftoverDef.groups or {}
-			leftoverDef.groups.not_in_creative_inventory=1
-			if industrialtest.mclAvailable then
-				leftoverDef._doc_items_create_entry=false
-			end
-			-- Item name starts with : to prevent name checks, because it seems to fail in on_mods_loaded
-			minetest.register_craftitem(":"..def.stackLeftover,leftoverDef)
-		end
-	end
-end)

api/side.lua

@@ -1,49 +0,0 @@
--- IndustrialTest
--- Copyright (C) 2024 mrkubax10
-
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
-
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
-
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
--- \brief Takes rotated node and side and outputs normalized side that can be used for ioConfig lookups
--- \param pos Vector with node position
--- \param side Node side. See industrialtest.api.addPowerStorage for possible values
--- \returns Normalized side or in case of failure side argument back
-function industrialtest.api.normalizeSide(pos,side)
-	local node=minetest.get_node(pos)
-	-- FIXME: improve code quality there
-	local translation={
-		[0]={
-			1,2,3,4,5,6
-		},
-		[1]={
-			5,6,3,4,1,2
-		},
-		[2]={
-			2,1,3,4,6,5
-		},
-		[3]={
-			6,5,3,4,2,1
-		}
-	}
-	if node.param2>3 then
-		return side
-	end
-	return translation[node.param2][side]
-end
-
--- \brief Returns opposite side of provided one
--- \param side Side number. See industrialtest.api.addPowerStorage for order
--- \returns Opposite side
-function industrialtest.api.getOppositeSide(side)
-	return (side%2==0 and side-1 or side+1)
-end

cables.lua

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

compat/logistica.lua

@@ -1,68 +0,0 @@
--- IndustrialTest
--- Copyright (C) 2024 mrkubax10
-
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
-
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
-
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-local oldInsertItemstackForRequester=logistica.insert_itemstack_for_requester
-
--- Logistica overrides
-function logistica.insert_itemstack_for_requester(requesterPos,itemstack,limitByRequest)
-	local result=oldInsertItemstackForRequester(requesterPos, itemstack, limitByRequest)
-
-	local targetPos=logistica.get_requester_target(requesterPos)
-	local def=minetest.registered_nodes[minetest.get_node(targetPos).name]
-	if def._logistica_afterRequesterItemstackInsert then
-		def._logistica_afterRequesterItemstackInsert(targetPos)
-	end
-
-	return result
-end
-
-local onInjectorTimer=logistica.on_timer_powered(function(pos,elapsed)
-	local result=logistica.on_injector_timer(pos,elapsed)
-
-	local targetPos=logistica.get_injector_target(pos)
-	local def=minetest.registered_nodes[minetest.get_node(targetPos).name]
-	if def._logistica_afterInjectorItemstackTake then
-		def._logistica_afterInjectorItemstackTake(targetPos)
-	end
-
-	return result
-end)
-
-for _,name in ipairs(logistica.group_get_all_nodes_for_group("injectors")) do
-	local override={
-		on_timer=onInjectorTimer
-	}
-	minetest.override_item(name,override)
-end
-
-local function afterLogisticaAction(pos)
-	local def=minetest.registered_nodes[minetest.get_node(pos).name]
-	if def and def._industrialtest_self then
-		def._industrialtest_self:triggerIfNeeded(pos)
-	end
-end
-
-local function addLogisticaCompatibility(name)
-	local override={
-		_logistica_afterRequesterItemstackInsert=afterLogisticaAction,
-		_logistica_afterInjectorItemstackTake=afterLogisticaAction
-	}
-	minetest.override_item(name,override)
-end
-
-for _,name in ipairs(industrialtest.api.tags.usesTimer) do
-	addLogisticaCompatibility(name)
-end

compat/mesecons.lua

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

compat/pipeworks.lua

@@ -41,10 +41,7 @@ local function addPipeworksCompatibility(name,sides,inputInventory)
 					return nil
 				end
 				local result=inv:add_item(listname,stack)
-				local def=minetest.registered_nodes[node.name]
+				minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-				if def and def._industrialtest_self then
-					def._industrialtest_self:triggerIfNeeded(pos)
-				end
 				return result
 			end,
 			can_insert=function(pos,node,stack,direction)
@@ -56,16 +53,6 @@ local function addPipeworksCompatibility(name,sides,inputInventory)
 				end
 				return inv:room_for_item(listname,stack)
 			end,
-			remove_items=function(pos,node,stack,direction,count,listname)
-				local meta=minetest.get_meta(pos)
-				local inv=meta:get_inventory()
-				inv:remove_item(listname,stack)
-				local def=minetest.registered_nodes[node.name]
-				if def and def._industrialtest_self then
-					def._industrialtest_self:triggerIfNeeded(pos)
-				end
-				return stack
-			end,
 			input_inventory=inputInventory,
 			connect_sides={
 				left=1,
@@ -170,8 +157,7 @@ local override={
 			local meta=minetest.get_meta(pos)
 			local inv=meta:get_inventory()
 			local result=inv:add_item(listname,stack)
-			industrialtest.Reactor.synchronizeChambers(pos)
+			minetest.registered_nodes["industrialtest:nuclear_reactor"].on_metadata_inventory_put(pos)
-			industrialtest.Reactor:triggerIfNeeded(pos)
 			return result
 		end,
 		can_insert=function(pos,node,stack,direction)
@@ -185,14 +171,6 @@ local override={
 			local inv=meta:get_inventory()
 			return inv:room_for_item(listname,stack)
 		end,
-		remove_items=function(pos,node,stack,direction,count,listname)
-			local meta=minetest.get_meta(pos)
-			local inv=meta:get_inventory()
-			inv:remove_item(listname,stack)
-			industrialtest.Reactor.synchronizeChambers(pos)
-			industrialtest.Reactor:triggerIfNeeded(pos)
-			return stack
-		end,
 		input_inventory="fuel",
 		connect_sides={
 			left=1,
@@ -229,22 +207,10 @@ override.tube.insert_object=function(pos,node,stack,direction)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local result=inv:add_item(listname,stack)
-	industrialtest.Reactor:synchronizeToChamber(pos)
+	minetest.registered_nodes["industrialtest:nuclear_reactor_chamber"].on_metadata_inventory_put(pos)
-	local reactorPos=minetest.deserialize(meta:get_string("reactor"))
-	industrialtest.Reactor:triggerIfNeeded(reactorPos)
 	return result
 end
 
-override.tube.remove_items=function(pos,node,stack,direction,count,listname)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	inv:remove_item(listname,stack)
-	industrialtest.Reactor:synchronizeToChamber(pos)
-	local reactorPos=minetest.deserialize(meta:get_string("reactor"))
-	industrialtest.Reactor:triggerIfNeeded(reactorPos)
-	return stack
-end
-
 override.after_place_node_old=def.after_place_node
 override.after_place_node=function(pos)
 	minetest.registered_nodes["industrialtest:nuclear_reactor_chamber"].after_place_node_old(pos)
@@ -303,21 +269,20 @@ override={
 			if direction.y==1 then
 				listname="powerStorage"
 			elseif direction.y==-1 then
-				listname="src"
+				listname="fuel"
 			else
-				listname="dst"
+				listname="target"
 			end
 			local def=stack:get_definition()
 			if (listname=="powerStorage" and not industrialtest.api.hasPowerStorage(stack:get_meta())) or
-				(listname=="src" and (not def.groups or not def.groups._industrialtest_fuel)) or
+				(listname=="fuel" and (not def.groups or not def.groups._industrialtest_fuel)) or
-				(listname=="dst" and (not def.groups or not def.groups._industrialtest_fueled)) then
+				(listname=="target" and (not def.groups or not def.groups._industrialtest_fueled)) then
 				return nil
 			end
 			local meta=minetest.get_meta(pos)
 			local inv=meta:get_inventory()
 			local result=inv:add_item(listname,stack)
-			local nodeDef=minetest.registered_nodes[node.name]
+			minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-			nodeDef._industrialtest_self:triggerIfNeeded(pos)
 			return result
 		end,
 		can_insert=function(pos,node,stack,direction)
@@ -325,28 +290,21 @@ override={
 			if direction.y==1 then
 				listname="powerStorage"
 			elseif direction.y==-1 then
-				listname="src"
+				listname="fuel"
 			else
-				listname="dst"
+				listname="target"
 			end
 			local def=stack:get_definition()
 			if (listname=="powerStorage" and not industrialtest.api.hasPowerStorage(stack:get_meta())) or
-				(listname=="src" and (not def.groups or not def.groups._industrialtest_fuel)) or
+				(listname=="fuel" and (not def.groups or not def.groups._industrialtest_fuel)) or
-				(listname=="dst" and (not def.groups or not def.groups._industrialtest_fueled)) then
+				(listname=="target" and (not def.groups or not def.groups._industrialtest_fueled)) then
 				return false
 			end
 			local meta=minetest.get_meta(pos)
 			local inv=meta:get_inventory()
 			return inv:room_for_item(listname,stack)
 		end,
-		remove_items=function(pos,node,stack,direction,count,listname)
+		input_inventory="target",
-			local meta=minetest.get_meta(pos)
-			local inv=meta:get_inventory()
-			inv:remove_item(listname,stack)
-			industrialtest.CanningMachine:triggerIfNeeded(pos)
-			return stack
-		end,
-		input_inventory="dst",
 		connect_sides={
 			left=1,
 			right=1,
@@ -386,7 +344,7 @@ addPipeworksCompatibility("industrialtest:induction_furnace",{
 },"dst")
 
 -- Simple electric item processors
-for _,name in ipairs(industrialtest.api.tags.simpleElectricItemProcessor) do
+for _,name in ipairs(industrialtest.internal.simpleElectricItemProcessors) do
 	addPipeworksCompatibility(name,{
 		{
 			y=1,

compatibility.lua

@@ -33,6 +33,12 @@ for _,mod in ipairs(requiredMclModules) do
 	end
 end
 
+if industrialtest.mtgAvailable then
+	industrialtest.stackMax=99
+elseif industrialtest.mclAvailable then
+	industrialtest.stackMax=64
+end
+
 industrialtest.mods={}
 if industrialtest.mtgAvailable then
 	industrialtest.mods._3dArmor=minetest.get_modpath("3d_armor")
@@ -40,7 +46,6 @@ elseif industrialtest.mclAvailable then
 	industrialtest.mods.mclRubber=minetest.get_modpath("mcl_rubber")
 end
 industrialtest.mods.pipeworks=minetest.get_modpath("pipeworks")
-industrialtest.mods.logistica=minetest.get_modpath("logistica")
 industrialtest.mods.mesecons=minetest.get_modpath("mesecons")
 
 if industrialtest.mtgAvailable and not industrialtest.mods._3dArmor then
@@ -48,11 +53,10 @@ if industrialtest.mtgAvailable and not industrialtest.mods._3dArmor then
 end
 
 industrialtest.elementKeys={}
+
 industrialtest.internal={}
 
 if industrialtest.mclAvailable then
-	industrialtest.stackMax=64
-
 	industrialtest.internal.mclMakeStrippedTrunk=function(itemstack,placer,pointedThing,electricTool)
 		-- Taken from https://git.minetest.land/MineClone2/MineClone2/src/branch/master/mods/ITEMS/mcl_tools/init.lua#L360
 		if pointedThing.type ~= "node" then return end
@@ -81,22 +85,9 @@ if industrialtest.mclAvailable then
 		end
 		return itemstack
 	end
-
 	industrialtest.internal.explode=function(pos,radius,dropChance)
 		mcl_explosions.explode(pos,radius,{drop_chance=dropChance})
 	end
-
-	industrialtest.internal.getItemSlotBg=mcl_formspec.get_itemslot_bg
-elseif industrialtest.mtgAvailable then
-	industrialtest.stackMax=99
-
-	industrialtest.internal.explode=function(pos,radius)
-		tnt.boom(pos,{radius=radius})
-	end
-
-	industrialtest.internal.getItemSlotBg=function()
-		return ""
-	end
 end
 
 -- compatibilty that adds not existing elements
@@ -203,7 +194,7 @@ if industrialtest.mclAvailable then
 		minetest.register_tool("industrialtest:"..material.."_pickaxe",{
 			description=S(materialDisplayName.." Pickaxe"),
 			inventory_image="industrialtest_mcl_"..material.."_pickaxe.png",
-			groups={tool=1,pickaxe=1,dig_speed_class=config.digSpeedClass,enchantability=config.enchantability},
+			groups={tool=1,pickaxe=1,dig_speed_class=config.digSpeedClass},
 			tool_capabilities={
 				full_punch_interval=1,
 				max_drop_level=config.dropLevel,
@@ -219,7 +210,7 @@ if industrialtest.mclAvailable then
 		minetest.register_tool("industrialtest:"..material.."_shovel",{
 			description=S(materialDisplayName.." Shovel"),
 			inventory_image="industrialtest_mcl_"..material.."_shovel.png",
-			groups={tool=1,shovel=1,dig_speed_class=config.digSpeedClass,enchantability=config.enchantability},
+			groups={tool=1,shovel=1,dig_speed_class=config.digSpeedClass},
 			tool_capabilities={
 				full_punch_interval=1,
 				max_drop_level=config.dropLevel,
@@ -262,7 +253,7 @@ if industrialtest.mclAvailable then
 				return itemstack
 			end,
 			sound={breaks="default_tool_breaks"},
-			_repair_material="industrialtest:"..materialItem,
+			_repair_material="industrialtest:"..material,
 			_mcl_toollike_wield=true,
 			_mcl_diggroups={
 				shovely={speed=config.speed,level=config.level,uses=config.uses}
@@ -271,7 +262,7 @@ if industrialtest.mclAvailable then
 		minetest.register_tool("industrialtest:"..material.."_axe",{
 			description=S(materialDisplayName.." Axe"),
 			inventory_image="industrialtest_mcl_"..material.."_axe.png",
-			groups={tool=1,axe=1,dig_speed_class=config.digSpeedClass,enchantability=config.enchantability},
+			groups={tool=1,axe=1,dig_speed_class=config.digSpeedClass},
 			tool_capabilities={
 				full_punch_interval=1,
 				max_level_drop=config.levelDrop,
@@ -279,7 +270,7 @@ if industrialtest.mclAvailable then
 			},
 			on_place=industrialtest.internal.mclMakeStrippedTrunk,
 			sound={breaks="default_tool_breaks"},
-			_repair_material="industrialtest:"..materialItem,
+			_repair_material="industrialtest:"..material,
 			_mcl_toollike_wield=true,
 			_mcl_diggroups={
 				axey={speed=config.speed,level=config.level,uses=config.uses}
@@ -288,14 +279,14 @@ if industrialtest.mclAvailable then
 		minetest.register_tool("industrialtest:"..material.."_sword",{
 			description=S(materialDisplayName.." Sword"),
 			inventory_image="industrialtest_mcl_"..material.."_sword.png",
-			groups={weapon=1,sword=1,dig_speed_class=config.digSpeedClass,enchantability=config.enchantability},
+			groups={weapon=1,sword=1,dig_speed_class=config.digSpeedClass},
 			tool_capabilities={
 				full_punch_interval=0.625,
 				max_drop_level=config.maxDropLevel,
 				damage_groups={fleshy=config.damage+2},
 			},
 			sound={breaks="default_tool_breaks"},
-			_repair_material="industrialtest:"..materialItem,
+			_repair_material="industrialtest:"..material,
 			_mcl_toollike_wield=true,
 			_mcl_diggroups={
 				swordy={speed=config.speed,level=config.level,uses=config.uses},
@@ -305,7 +296,7 @@ if industrialtest.mclAvailable then
 		minetest.register_tool("industrialtest:"..material.."_hoe",{
 			description=S(materialDisplayName.." Hoe"),
 			inventory_image="industrialtest_mcl_"..material.."_hoe.png",
-			groups={tool=1,hoe=1,enchantability=config.enchantability},
+			groups={tool=1,hoe=1},
 			tool_capabilities={
 				full_punch_interval=1,
 				damage_groups={fleshy=1}
@@ -358,7 +349,7 @@ if industrialtest.mclAvailable then
 					return itemstack
 				end
 			end,
-			_repair_material="industrialtest:"..materialItem,
+			_repair_material="industrialtest:"..material,
 			_mcl_toollike_wield=true,
 			_mcl_diggroups={
 				hoey={speed=config.speed,level=config.level,uses=config.uses}
@@ -369,11 +360,10 @@ if industrialtest.mclAvailable then
 			description=materialDisplayName,
 			durability=config.uses,
 			points=config.armorPoints,
-			craft_material="industrialtest:"..materialItem,
+			craft_material="industrialtest:"..material,
 			cook_material=config.armorCookMaterial,
 			sound_equip=config.armorEquipSound,
 			sound_unequip=config.armorUnequipSound,
-			enchantability=config.enchantability,
 			textures={
 				head="industrialtest_mcl_"..material.."_helmet.png",
 				torso="industrialtest_mcl_"..material.."_chestplate.png",
@@ -450,7 +440,6 @@ if industrialtest.mclAvailable then
 	industrialtest.elementKeys.stick="mcl_core:stick"
 	industrialtest.elementKeys.flint="mcl_core:flint"
 	industrialtest.elementKeys.snowball="mcl_throwing:snowball"
-	industrialtest.elementKeys.snowBlock="mcl_core:snowblock"
 	industrialtest.elementKeys.string="mcl_mobitems:string"
 	industrialtest.elementKeys.junglePlanks="mcl_core:junglewood"
 	industrialtest.elementKeys.wood="mcl_core:tree"
@@ -506,7 +495,6 @@ if industrialtest.mclAvailable then
 	industrialtest.elementKeys.dryShrub="mcl_core:deadbush"
 	industrialtest.elementKeys.cactus="mcl_core:cactus"
 	industrialtest.elementKeys.gunpowder="mcl_mobitems:gunpowder"
-	industrialtest.elementKeys.chest="mcl_chests:chest_small"
 	industrialtest.elementKeys.groupSapling="group:sapling"
 	industrialtest.elementKeys.groupLeaves="group:leaves"
 	industrialtest.elementKeys.stickyResin=(industrialtest.mods.mclRubber and "mcl_rubber:rubber_raw" or "industrialtest:sticky_resin")
@@ -533,7 +521,7 @@ if industrialtest.mclAvailable then
 	})
 	minetest.register_craft({
 		type="shaped",
-		output="industrialtest:bronze_ingot 9",
+		output="industrialcraft:bronze_ingot 9",
 		recipe={
 			{"mcl_copper:copper_ingot","mcl_copper:copper_ingot","mcl_copper:copper_ingot"},
 			{"mcl_copper:copper_ingot","industrialtest:tin_ingot","mcl_copper:copper_ingot"},
@@ -579,8 +567,7 @@ if industrialtest.mclAvailable then
 		},
 		armorCookMaterial="industrialtest:bronze_nugget",
 		armorEquipSound="mcl_armor_equip_iron",
-		armorUnequipSound="mcl_armor_unequip_iron",
+		armorUnequipSound="mcl_armor_unequip_iron"
-		enchantability=15,
 	})
 
 	--register other blocks that are not availabe in MCL
@@ -624,6 +611,10 @@ if industrialtest.mclAvailable then
 		y_min=mcl_vars.mg_overworld_min
 	})
 elseif industrialtest.mtgAvailable then
+	industrialtest.internal.explode=function(pos,radius)
+		tnt.boom(pos,{radius=radius})
+	end
+
 	industrialtest.internal.registerMetal=function(name,displayName,hardness)
 		minetest.register_craftitem("industrialtest:"..name.."_lump",{
 			description=S(displayName.." Lump"),
@@ -692,7 +683,6 @@ elseif industrialtest.mtgAvailable then
 	industrialtest.elementKeys.stick="default:stick"
 	industrialtest.elementKeys.flint="default:flint"
 	industrialtest.elementKeys.snowball="default:snow"
-	industrialtest.elementKeys.snowBlock="default:snowblock"
 	industrialtest.elementKeys.blueDye="dye:blue"
 	industrialtest.elementKeys.yellowDust="dye:yellow"
 	industrialtest.elementKeys.bucket="bucket:bucket_empty"
@@ -741,7 +731,6 @@ elseif industrialtest.mtgAvailable then
 	industrialtest.elementKeys.dryShrub="default:dry_shrub"
 	industrialtest.elementKeys.cactus="default:cactus"
 	industrialtest.elementKeys.gunpowder="tnt:gunpowder"
-	industrialtest.elementKeys.chest="default:chest"
 	industrialtest.elementKeys.groupSapling="group:sapling"
 	industrialtest.elementKeys.groupLeaves="group:leaves"
 	industrialtest.elementKeys.stickyResin="industrialtest:sticky_resin"

craftitems.lua

@@ -15,31 +15,75 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-local colors={
+
-	bronze="#be4325ff",
+-- Power storage items
-	clay="#707070ff",
+minetest.register_tool("industrialtest:re_battery",{
-	coal="#262523ff",
+	description=S("RE-Battery"),
-	copper="#bf644aff",
+	inventory_image="industrialtest_re_battery.png",
-	diamond="#77cefbff",
+	_industrialtest_powerStorage=true,
-	gold="#eac162ff",
+	_industrialtest_powerCapacity=7000,
-	iron="#afaca5ff",
+	_industrialtest_powerFlow=industrialtest.api.lvPowerFlow
-	lapis_lazuli="#3a4cceff",
+})
-	lead="#6d6393ff",
+minetest.register_craft({
-	mese="#909000ff",
+	type="shaped",
-	obsidian="#292843ff",
+	output="industrialtest:re_battery",
-	refined_iron="#94bab9ff",
+	recipe={
-	sulfur="#b88805ff",
+		{"","industrialtest:insulated_tin_cable",""},
-	tin="#ebd182ff",
+		{industrialtest.elementKeys.tinIngot,industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.tinIngot},
-	uranium="#3b8c09ff",
+		{industrialtest.elementKeys.tinIngot,industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.tinIngot}
-	-- fluid colors
-	lava="#ff5712ff",
-	water="#277bbcff",
-	river_water="#0ebfc2ff",
-	biomass="#2a8626ff",
-	biofuel="#4eba49ff",
-	coalfuel="#462228ff",
-	coolant="#188676ff"
 	}
+})
+
+minetest.register_tool("industrialtest:advanced_re_battery",{
+	description=S("Advanced RE-Battery"),
+	inventory_image="industrialtest_advanced_re_battery.png",
+	_industrialtest_powerStorage=true,
+	_industrialtest_powerCapacity=100000,
+	_industrialtest_powerFlow=industrialtest.api.mvPowerFlow
+})
+minetest.register_craft({
+	type="shaped",
+	output="industrialtest:advanced_re_battery",
+	recipe={
+		{"industrialtest:insulated_copper_cable",industrialtest.elementKeys.bronzeIngot,"industrialtest:insulated_copper_cable"},
+		{industrialtest.elementKeys.bronzeIngot,"industrialtest:sulfur_dust",industrialtest.elementKeys.bronzeIngot},
+		{industrialtest.elementKeys.bronzeIngot,"industrialtest:lead_dust",industrialtest.elementKeys.bronzeIngot}
+	}
+})
+
+minetest.register_tool("industrialtest:energy_crystal",{
+	description=S("Energy Crystal"),
+	inventory_image="industrialtest_energy_crystal.png",
+	_industrialtest_powerStorage=true,
+	_industrialtest_powerCapacity=100000,
+	_industrialtest_powerFlow=industrialtest.api.hvPowerFlow
+})
+minetest.register_craft({
+	type="shaped",
+	output="industrialtest:energy_crystal",
+	recipe={
+		{industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.powerCarrier},
+		{industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.diamond,industrialtest.elementKeys.powerCarrier},
+		{industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.powerCarrier,industrialtest.elementKeys.powerCarrier}
+	}
+})
+
+minetest.register_tool("industrialtest:lapotron_crystal",{
+	description=S("Lapotron Crystal"),
+	inventory_image="industrialtest_lapotron_crystal.png",
+	_industrialtest_powerStorage=true,
+	_industrialtest_powerCapacity=1000000,
+	_industrialtest_powerFlow=industrialtest.api.evPowerFlow
+})
+minetest.register_craft({
+	type="shaped",
+	output="industrialtest:lapotron_crystal",
+	recipe={
+		{industrialtest.elementKeys.blueDye,"industrialtest:electronic_circuit",industrialtest.elementKeys.blueDye},
+		{industrialtest.elementKeys.blueDye,"industrialtest:energy_crystal",industrialtest.elementKeys.blueDye},
+		{industrialtest.elementKeys.blueDye,"industrialtest:electronic_circuit",industrialtest.elementKeys.blueDye}
+	}
+})
 
 -- Other resources
 minetest.register_craftitem("industrialtest:refined_iron_ingot",{
@@ -153,13 +197,13 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("coal","Coal",resources,colors.coal,true)
+industrialtest.api.registerResourceDust("coal","Coal",resources,"#101010ff",true)
 industrialtest.api.registerResourceDust("clay","Clay",{
 	{
 		resource=industrialtest.elementKeys.clayBlock,
 		count=2
 	}
-},colors.clay,true)
+},"#9090a0ff",true)
 resources={
 	{
 		resource=industrialtest.elementKeys.diamondBlock,
@@ -177,7 +221,7 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("diamond","Diamond",resources,colors.diamond,true)
+industrialtest.api.registerResourceDust("diamond","Diamond",resources,"#90e2c9ff",true)
 minetest.register_craft({
 	type="cooking",
 	output=industrialtest.elementKeys.diamond,
@@ -204,7 +248,7 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("iron","Iron",resources,colors.iron,true)
+industrialtest.api.registerResourceDust("iron","Iron",resources,"#b5b5b5ff",true)
 minetest.register_craft({
 	type="cooking",
 	output=industrialtest.elementKeys.ironIngot,
@@ -225,9 +269,9 @@ if industrialtest.mclAvailable then
 			count=9
 		},
 		{resource="mcl_core:lapis_lazuli"}
-	},colors.lapis_lazuli,true)
+	},"#292d76ff",true)
 end
-industrialtest.api.registerResourceDust("obsidian","Obsidian",{{resource=industrialtest.elementKeys.obsidian}},colors.obsidian,true)
+industrialtest.api.registerResourceDust("obsidian","Obsidian",{{resource=industrialtest.elementKeys.obsidian}},"#292843ff",true)
 resources={
 	{
 		resource=industrialtest.elementKeys.goldBlock,
@@ -249,7 +293,7 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("gold","Gold",resources,colors.gold,true)
+industrialtest.api.registerResourceDust("gold","Gold",resources,"#e4e526ff",true)
 minetest.register_craft({
 	type="cooking",
 	output=industrialtest.elementKeys.goldIngot,
@@ -276,7 +320,7 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("copper","Copper",resources,colors.copper,true)
+industrialtest.api.registerResourceDust("copper","Copper",resources,"#a45e25ff",true)
 minetest.register_craft({
 	type="cooking",
 	output=industrialtest.elementKeys.copperIngot,
@@ -303,7 +347,7 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("tin","Tin",resources,colors.tin,true)
+industrialtest.api.registerResourceDust("tin","Tin",resources,"#f1f1f1ff",true)
 minetest.register_craft({
 	type="cooking",
 	output=industrialtest.elementKeys.tinIngot,
@@ -330,7 +374,7 @@ if industrialtest.mclAvailable then
 		count=2
 	})
 end
-industrialtest.api.registerResourceDust("uranium","Uranium",resources,colors.uranium,true)
+industrialtest.api.registerResourceDust("uranium","Uranium",resources,"#3b8c09ff",true)
 minetest.register_craft({
 	type="cooking",
 	output="industrialtest:uranium_ingot",
@@ -347,7 +391,7 @@ if industrialtest.mtgAvailable then
 			count=2
 		},
 		{resource="default:mese_crystal"}
-	},colors.mese,true)
+	},"#909000ff",true)
 	minetest.register_craft({
 		type="cooking",
 		output="default:mese_crystal",
@@ -360,7 +404,7 @@ industrialtest.api.registerResourceDust("bronze","Bronze",{
 		count=9
 	},
 	{resource=industrialtest.elementKeys.bronzeIngot}
-},colors.bronze,true)
+},"#e48e88ff",true)
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:bronze_dust 9",
@@ -387,7 +431,7 @@ industrialtest.api.registerRotaryMaceratorModifier({
 	output="industrialtest:bronze_dust",
 	uses=4
 })
-industrialtest.api.registerResourceDust("sulfur","Sulfur",{},colors.sulfur,false)
+industrialtest.api.registerResourceDust("sulfur","Sulfur",{},"#e3ff33ff",false)
 industrialtest.api.registerExtractorRecipe({
 	output="industrialtest:sulfur_dust",
 	recipe=industrialtest.elementKeys.gunpowder
@@ -406,7 +450,7 @@ industrialtest.api.registerResourceDust("lead","Lead",{
 		count=2
 	},
 	{resource="industrialtest:lead_ingot"}
-},colors.lead,true)
+},"#eafef8ff",true)
 minetest.register_craft({
 	type="cooking",
 	output="industrialtest:lead_ingot",
@@ -417,7 +461,7 @@ industrialtest.api.registerResourceDust("refined_iron","Refined Iron",{
 		resource="industrialtest:refined_iron_ingot",
 		count=1
 	}
-},colors.refined_iron,true)
+},"#7c8588ff",true)
 industrialtest.api.registerRotaryMaceratorModifier({
 	name=industrialtest.elementKeys.ironLump,
 	modifier=industrialtest.elementKeys.coal,
@@ -480,14 +524,14 @@ industrialtest.api.registerPlate("bronze_plate",S("Bronze Plate"),{
 		resource=industrialtest.elementKeys.bronzeIngot,
 		count=1
 	}
-},colors.bronze,true)
+},"#e48e88ff",true)
 
 industrialtest.api.registerPlate("copper_plate",S("Copper Plate"),{
 	{
 		resource=industrialtest.elementKeys.copperIngot,
 		count=1
 	}
-},colors.copper,true)
+},"#f48e44ff",true)
 
 industrialtest.api.registerPlate("advanced_alloy",S("Advanced Alloy"),{
 	{
@@ -508,14 +552,14 @@ industrialtest.api.registerPlate("tin_plate",S("Tin Plate"),{
 		resource=industrialtest.elementKeys.tinIngot,
 		count=1
 	}
-},colors.tin,true)
+},"#e0e0e0ff",true)
 
 industrialtest.api.registerPlate("lead_plate",S("Lead Plate"),{
 	{
 		resource="industrialtest:lead_ingot",
 		count=1
 	}
-},colors.lead,true)
+},"#eafef8ff",true)
 
 industrialtest.api.registerPlate("iridium_plate",S("Iridium Plate"),{},false,"#ffffffff")
 minetest.register_craft({
@@ -565,12 +609,12 @@ minetest.register_craft({
 		{"",industrialtest.elementKeys.tinIngot,""}
 	}
 })
-industrialtest.api.registerStorageCell("water","Water",industrialtest.elementKeys.waterSource,nil,colors.water)
+industrialtest.api.registerStorageCell("water","Water",industrialtest.elementKeys.waterSource)
 if industrialtest.mtgAvailable then
-	industrialtest.api.registerStorageCell("river_water","River Water","default:river_water_source",nil,colors.river_water)
+	industrialtest.api.registerStorageCell("river_water","River Water","default:river_water_source")
 end
 
-industrialtest.api.registerStorageCell("lava","Lava",industrialtest.elementKeys.lavaSource,nil,colors.lava)
+industrialtest.api.registerStorageCell("lava","Lava",industrialtest.elementKeys.lavaSource)
 
 minetest.register_tool("industrialtest:uranium_cell",{
 	description=S("Uranium Cell"),
@@ -578,9 +622,7 @@ minetest.register_tool("industrialtest:uranium_cell",{
 		_industrialtest_placedInNuclearReactor=1,
 		_industrialtest_nuclearReactorFuel=1
 	},
-	inventory_image="industrialtest_cell_fluid.png",
+	inventory_image="industrialtest_uranium_cell.png",
-	inventory_overlay="industrialtest_cell_casing.png",
-	color=colors.uranium,
 })
 minetest.register_craft({
 	type="shapeless",
@@ -597,9 +639,7 @@ minetest.register_tool("industrialtest:coolant_cell",{
 		_industrialtest_placedInNuclearReactor=1,
 		_industrialtest_nuclearReactorCoolant=1
 	},
-	inventory_image="industrialtest_cell_fluid.png",
+	inventory_image="industrialtest_coolant_cell.png",
-	inventory_overlay="industrialtest_cell_casing.png",
-	color=colors.coolant,
 })
 minetest.register_craft({
 	type="shaped",
@@ -624,9 +664,7 @@ end
 
 minetest.register_craftitem("industrialtest:bio_cell",{
 	description=S("Bio Cell"),
-	inventory_image="industrialtest_cell_fluid.png",
+	inventory_image="industrialtest_bio_cell.png"
-	inventory_overlay="industrialtest_cell_casing.png",
-	color=colors.biomass,
 })
 minetest.register_craft({
 	type="shapeless",
@@ -639,9 +677,7 @@ minetest.register_craft({
 
 minetest.register_craftitem("industrialtest:biofuel_cell",{
 	description=S("Biofuel Cell"),
-	inventory_image="industrialtest_cell_fluid.png",
+	inventory_image="industrialtest_bio_cell.png",
-	inventory_overlay="industrialtest_cell_casing.png",
-	color=colors.biofuel,
 	groups={
 		_industrialtest_fuel=1
 	},
@@ -656,9 +692,7 @@ industrialtest.api.registerExtractorRecipe({
 
 minetest.register_craftitem("industrialtest:hydrated_coal_cell",{
 	description=S("Hydrated Coal Cell"),
-	inventory_image="industrialtest_cell_fluid.png",
+	inventory_image="industrialtest_hydrated_coal_cell.png"
-	inventory_overlay="industrialtest_cell_casing.png",
-	color=colors.coal,
 })
 minetest.register_craft({
 	type="shapeless",
@@ -671,9 +705,7 @@ minetest.register_craft({
 
 minetest.register_craftitem("industrialtest:coalfuel_cell",{
 	description=S("Coalfuel Cell"),
-	inventory_image="industrialtest_cell_fluid.png",
+	inventory_image="industrialtest_coalfuel_cell.png",
-	inventory_overlay="industrialtest_cell_casing.png",
-	color=colors.coalfuel,
 	groups={
 		_industrialtest_fuel=1
 	},
@@ -802,3 +834,38 @@ industrialtest.api.registerCompressorRecipe({
 	recipe="industrialtest:plantball",
 	time=5
 })
+
+minetest.register_tool("industrialtest:fuel_can",{
+	description=S("Fuel Can"),
+	inventory_image="industrialtest_fuel_can.png",
+	groups={
+		_industrialtest_fueled=1,
+		_industrialtest_fuel=1,
+		_industrialtest_fluidStorage=1
+	},
+	_industrialtest_fluidCapacity=10000
+})
+minetest.register_craft({
+	type="shaped",
+	output="industrialtest:fuel_can",
+	recipe={
+		{"","industrialtest:tin_plate","industrialtest:tin_plate"},
+		{"industrialtest:tin_plate","","industrialtest:tin_plate"},
+		{"industrialtest:tin_plate","industrialtest:tin_plate","industrialtest:tin_plate"}
+	}
+})
+
+-- Item callbacks
+minetest.register_on_player_inventory_action(function(player,action,inventory,info)
+	if action=="put" then
+		if industrialtest.api.preparePowerStorageItem(info.stack) or industrialtest.api.prepareToolItem(info.stack) or industrialtest.api.prepareFluidStorageItem(info.stack) then
+			inventory:set_stack(info.listname,info.index,info.stack)
+		end
+	end
+end)
+minetest.register_on_craft(function(itemstack)
+	if industrialtest.api.preparePowerStorageItem(itemstack) or industrialtest.api.prepareToolItem(itemstack) then
+		return
+	end
+	industrialtest.api.prepareFluidStorageItem(itemstack)
+end)

init.lua

@@ -14,37 +14,25 @@
 -- 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 modpath=minetest.get_modpath("industrialtest")
+MODNAME="industrialtest"
+local modpath=minetest.get_modpath(MODNAME)
 
 -- table with global functions, variables etc
 industrialtest={}
 
--- Settings
+-- Initial constants
-industrialtest.config={
+industrialtest.updateDelay=1 -- Note: Make this value smaller to make machines update more frequently (it may make server more laggy)
-	updateDelay=tonumber(minetest.settings:get("industrialtest.updateDelay") or "1"),
+industrialtest.developerMode=true -- Enables additional utils useful when developing mod
-	electrocution=minetest.settings:get_bool("industrialtest.electrocution",true),
-	developerMode=minetest.settings:get_bool("industrialtest.developerMode",false)
-}
 
 -- Others
 industrialtest.random=PseudoRandom(os.time())
 
 -- load other lua files
 dofile(modpath.."/compatibility.lua")
+dofile(modpath.."/api.lua")
 dofile(modpath.."/minerals.lua")
 
-dofile(modpath.."/api/common.lua")
+dofile(modpath.."/machines/common.lua")
-dofile(modpath.."/api/fluid.lua")
-dofile(modpath.."/api/network.lua")
-dofile(modpath.."/api/power.lua")
-dofile(modpath.."/api/registration.lua")
-dofile(modpath.."/api/side.lua")
-
-dofile(modpath.."/machines/machine.lua")
-dofile(modpath.."/machines/activated_machine.lua")
-dofile(modpath.."/machines/electric_machine.lua")
-dofile(modpath.."/machines/activated_electric_machine.lua")
-dofile(modpath.."/machines/simple_electric_item_processor.lua")
 dofile(modpath.."/machines/canning_machine.lua")
 dofile(modpath.."/machines/chargepad.lua")
 dofile(modpath.."/machines/compressor.lua")
@@ -57,7 +45,6 @@ dofile(modpath.."/machines/induction_furnace.lua")
 dofile(modpath.."/machines/iron_furnace.lua")
 dofile(modpath.."/machines/macerator.lua")
 dofile(modpath.."/machines/mass_fabricator.lua")
-dofile(modpath.."/machines/miner.lua")
 dofile(modpath.."/machines/nuclear_reactor.lua")
 dofile(modpath.."/machines/power_storage.lua")
 dofile(modpath.."/machines/recycler.lua")
@@ -68,26 +55,14 @@ dofile(modpath.."/machines/solar_panel_generator.lua")
 dofile(modpath.."/machines/wind_mill.lua")
 
 dofile(modpath.."/tools/common.lua")
-dofile(modpath.."/tools/item.lua")
-dofile(modpath.."/tools/electric_item.lua")
-dofile(modpath.."/tools/electric_armor.lua")
-dofile(modpath.."/tools/fluid_container_item.lua")
-dofile(modpath.."/tools/tool.lua")
-dofile(modpath.."/tools/gear_tool.lua")
-dofile(modpath.."/tools/electric_tool.lua")
-dofile(modpath.."/tools/activated_electric_tool.lua")
-dofile(modpath.."/tools/electric_gear_tool.lua")
 dofile(modpath.."/tools/batpack.lua")
 dofile(modpath.."/tools/electric_chainsaw.lua")
 dofile(modpath.."/tools/electric_drill.lua")
 dofile(modpath.."/tools/electric_hoe.lua")
 dofile(modpath.."/tools/electric_saber.lua")
-dofile(modpath.."/tools/fluid_storage.lua")
 dofile(modpath.."/tools/jetpack.lua")
 dofile(modpath.."/tools/mining_laser.lua")
 dofile(modpath.."/tools/nano_suit.lua")
-dofile(modpath.."/tools/power_storage.lua")
-dofile(modpath.."/tools/scanner.lua")
 dofile(modpath.."/tools/solar_helmet.lua")
 dofile(modpath.."/tools/static_boots.lua")
 dofile(modpath.."/tools/treetap.lua")
@@ -97,7 +72,7 @@ dofile(modpath.."/tools/wrench.lua")
 dofile(modpath.."/upgrades.lua")
 dofile(modpath.."/craftitems.lua")
 dofile(modpath.."/nodes.lua")
-if industrialtest.config.developerMode then
+if industrialtest.developerMode then
 	dofile(modpath.."/utils.lua")
 end
 dofile(modpath.."/cables.lua")
@@ -109,9 +84,6 @@ dofile(modpath.."/crafts.lua")
 if industrialtest.mods.pipeworks then
 	dofile(modpath.."/compat/pipeworks.lua")
 end
-if industrialtest.mods.logistica then
-	dofile(modpath.."/compat/logistica.lua")
-end
 if industrialtest.mods.mesecons then
 	dofile(modpath.."/compat/mesecons.lua")
 end

machines/activated_electric_machine.lua

@@ -1,44 +0,0 @@
--- IndustrialTest
--- Copyright (C) 2024 mrkubax10
-
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
-
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
-
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-industrialtest.ActivatedElectricMachine=table.copy(industrialtest.ElectricMachine)
-
--- Forward methods from ActivatedMachine
-industrialtest.internal.unpackTableInto(industrialtest.ActivatedElectricMachine,{
-	canUpdate=industrialtest.ActivatedMachine.canUpdate,
-	register=industrialtest.ActivatedMachine.register,
-	createDefinitionTable=industrialtest.ActivatedMachine.createDefinitionTable,
-	createActiveDefinitionTable=industrialtest.ActivatedMachine.createActiveDefinitionTable,
-	activate=industrialtest.ActivatedMachine.activate,
-	deactivate=industrialtest.ActivatedMachine.deactivate,
-	shouldActivate=industrialtest.ActivatedMachine.shouldActivate,
-	shouldDeactivate=industrialtest.ActivatedMachine.shouldDeactivate,
-	afterActivation=industrialtest.ActivatedMachine.afterActivation,
-	afterDeactivation=industrialtest.ActivatedMachine.afterDeactivation
-})
-
-function industrialtest.ActivatedElectricMachine.onTimer(self,pos,elapsed)
-	local result=self:powerExchange(pos)
-	local result2=industrialtest.ActivatedMachine.onTimer(self,pos,elapsed)
-	return result or result2
-end
-
-function industrialtest.ActivatedElectricMachine.activeOnTimer(self,pos,elapsed)
-	local result=self:powerExchange(pos)
-	local result2=industrialtest.ActivatedMachine.activeOnTimer(self,pos,elapsed)
-	return result or result2
-end
-

machines/activated_machine.lua

@@ -1,114 +0,0 @@
--- IndustrialTest
--- Copyright (C) 2024 mrkubax10
-
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
-
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
-
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-industrialtest.ActivatedMachine=table.copy(industrialtest.Machine)
-
-function industrialtest.ActivatedMachine.canUpdate(self,pos)
-	return self:shouldActivate(pos)
-end
-
-function industrialtest.ActivatedMachine.onTimer(self,pos,elapsed)
-	local result=industrialtest.Machine.onTimer(self,pos,elapsed)
-
-	if self:shouldActivate(pos) then
-		self:activate(pos)
-		return false
-	end
-
-	return result
-end
-
-function industrialtest.ActivatedMachine.register(self)
-	industrialtest.Machine.register(self)
-
-	local def=self:createActiveDefinitionTable()
-	minetest.register_node(self.name.."_active",def)
-end
-
-function industrialtest.ActivatedMachine.createActiveDefinitionTable(self)
-	local def=self:createDefinitionTable()
-	def.description=nil
-	def.drop=def.drop or self.name
-
-	if self.active then
-		def.tiles=self.active.tiles or def.tiles
-		def.light_source=self.active.lightSource
-	end
-
-	def.on_timer=function(pos,elapsed)
-		return self:activeOnTimer(pos,elapsed)
-	end
-
-	if industrialtest.mclAvailable then
-		def.groups.not_in_creative_inventory=1
-		def._doc_items_create_entry=false
-	end
-
-	return def
-end
-
-function industrialtest.ActivatedMachine.activate(self,pos)
-	minetest.swap_node(pos,{
-		name=self.name.."_active",
-		param2=minetest.get_node(pos).param2
-	})
-	self:afterActivation(pos)
-	minetest.get_node_timer(pos):start(industrialtest.config.updateDelay)
-end
-
-function industrialtest.ActivatedMachine.deactivate(self,pos)
-	minetest.swap_node(pos,{
-		name=self.name,
-		param2=minetest.get_node(pos).param2
-	})
-	self:afterDeactivation(pos)
-	minetest.get_node_timer(pos):start(industrialtest.config.updateDelay)
-end
-
-function industrialtest.ActivatedMachine.shouldActivate(self,pos)
-	return false
-end
-
-function industrialtest.ActivatedMachine.shouldDeactivate(self,pos)
-	return false
-end
-
-function industrialtest.ActivatedMachine.afterActivation(self,pos)
-end
-
-function industrialtest.ActivatedMachine.afterDeactivation(self,pos)
-end
-
-function industrialtest.ActivatedMachine.activeOnTimer(self,pos,elapsed)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local shouldUpdateFormspec=false
-
-	if self:shouldDeactivate(pos) then
-		self:deactivate(pos)
-		return false
-	end
-
-	if self.activeUpdate then
-		shouldUpdateFormspec=self:activeUpdate(pos,elapsed,meta,inv)
-	end
-
-	if shouldUpdateFormspec then
-		self:updateFormspec(pos)
-	end
-
-	return true
-end

machines/cable_former.lua

@@ -15,55 +15,18 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.CableFormer=table.copy(industrialtest.SimpleElectricItemProcessor)
+
-industrialtest.internal.unpackTableInto(industrialtest.CableFormer,{
+industrialtest.internal.registerSimpleElectricItemProcessor({
-	name="industrialtest:cable_former",
+	name="cable_former",
-	description=S("Cable Former"),
+	displayName=S("Cable Former"),
-	tiles={
+	customFrontTexture=true,
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_cable_former_front.png"
-	},
 	requiresWrench=true,
-	active={
-		tiles={
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png^industrialtest_cable_former_front_active.png"
-		}
-	},
 	capacity=1400,
 	flow=industrialtest.api.lvPowerFlow,
 	opPower=80,
+	method="industrialtest.cable_forming",
 	efficiency=1
 })
-
-function industrialtest.CableFormer.getCraftResult(self,itemstack)
-	local output=industrialtest.api.getCableFormerRecipeResult(itemstack:get_name())
-	if not output then
-		return {
-			item=ItemStack(),
-			time=0,
-			src=itemstack
-		}
-	end
-	local srcAfter=ItemStack(itemstack:get_name())
-	srcAfter:set_count(itemstack:get_count()-1)
-	return {
-		item=ItemStack(output.output),
-		time=output.time,
-		src=srcAfter
-	}
-end
-
-industrialtest.CableFormer:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:cable_former",

machines/canning_machine.lua

@@ -15,10 +15,229 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.CanningMachine=table.copy(industrialtest.ActivatedElectricMachine)
+local canningMachine={}
-industrialtest.internal.unpackTableInto(industrialtest.CanningMachine,{
+
+canningMachine.opPower=200
+canningMachine.canningTime=5
+
+canningMachine.getFormspec=function(pos)
+	local meta=minetest.get_meta(pos)
+	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
+	local srcPercent=meta:get_float("srcTime")/canningMachine.canningTime*100
+	local formspec
+	if industrialtest.mtgAvailable then
+		formspec={
+			"list[context;fuel;3.4,1.8;1,1]",
+			(powerPercent>0 and "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
+			 or "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
+			"list[context;powerStorage;3.4,3.9;1,1]",
+			(srcPercent>0 and "image[4.9,1.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
+			 or "image[4.9,1.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
+			"list[context;target;6.4,1.8;1,1]",
+			"list[context;leftover;6.4,2.8;1,1]",
+			"list[context;upgrades;9,0.9;1,4]",
+			"listring[context;fuel]",
+			"listring[context;powerStorage]",
+			"listring[context;target]",
+			"listring[context;leftover]",
+			"listring[context;upgrades]"
+		}
+	elseif industrialtest.mclAvailable then
+		formspec={
+		"list[context;fuel;3.4,1.8;1,1]",
+		mcl_formspec.get_itemslot_bg(3.4,1.8,1,1),
+		(powerPercent>0 and "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
+		 or "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
+		"list[context;powerStorage;3.4,3.9;1,1]",
+		mcl_formspec.get_itemslot_bg(3.4,3.9,1,1),
+		(srcPercent>0 and "image[4.9,1.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
+		 or "image[4.9,1.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
+		"list[context;target;6.4,1.8;1,1]",
+		mcl_formspec.get_itemslot_bg(6.4,1.8,1,1),
+		"list[context;leftover;6.4,2.8;1,1]",
+		mcl_formspec.get_itemslot_bg(6.4,2.8,1,1),
+		"list[context;upgrades;9,0.9;1,4]",
+		mcl_formspec.get_itemslot_bg(9,0.9,1,4),
+		"listring[context;fuel]",
+		"listring[context;powerStorage]",
+		"listring[context;target]",
+		"listring[context;upgrades]"
+		}
+	end
+	return table.concat(formspec,"")
+end
+
+canningMachine.onConstruct=function(pos,meta,inv)
+	inv:set_size("fuel",1)
+	inv:set_size("target",1)
+	inv:set_size("leftover",1)
+	inv:set_size("powerStorage",1)
+	inv:set_size("upgrades",4)
+	meta:set_float("srcTime",0)
+end
+
+canningMachine.onTimer=function(pos,elapsed,meta,inv)
+	local shouldRerunTimer=false
+	local shouldUpdateFormspec=false
+	local fuelSlot=inv:get_stack("fuel",1)
+	local targetSlot=inv:get_stack("target",1)
+	local leftoverSlot=inv:get_stack("leftover",1)
+	local powerStorageSlot=inv:get_stack("powerStorage",1)
+	local targetMeta=targetSlot:get_meta()
+
+	shouldRerunTimer,shouldUpdateFormspec=industrialtest.internal.chargeFromPowerStorageItem(meta,inv)
+
+	local def=fuelSlot:get_definition()
+	if not fuelSlot:is_empty() and not targetSlot:is_empty() and meta:get_int("industrialtest.powerAmount")>=canningMachine.opPower and (not def._industrialtest_emptyVariant or leftoverSlot:item_fits(ItemStack(def._industrialtest_emptyVariant))) and
+		(not industrialtest.api.itemHasFluidStorage(fuelSlot) or fuelSlot:get_meta():get_int("industrialtest.fluidAmount")>0) and targetMeta:get_int("industrialtest.fluidAmount")<targetMeta:get_int("industrialtest.fluidCapacity") then
+		minetest.swap_node(pos,{
+			name="industrialtest:canning_machine_active",
+			param2=minetest.get_node(pos).param2
+		})
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		return false,shouldUpdateFormspec
+	end
+	
+	return shouldRerunTimer,true
+end
+
+canningMachine.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,count)
+	if toList=="fuel" then
+		local inv=minetest.get_meta(pos):get_inventory()
+		local itemstack=inv:get_stack(fromList,fromIndex)
+		local def=itemstack:get_definition()
+		return (def.groups and def.groups._industrialtest_fuel) and count or 0
+	end
+	if toList=="target" then
+		local inv=minetest.get_meta(pos):get_inventory()
+		local itemstack=inv:get_stack(fromList,fromIndex)
+		local def=itemstack:get_definition()
+		return (def.groups and def.groups._industrialtest_fueled) and count or 0
+	end
+	return count
+end
+
+canningMachine.allowMetadataInventoryPut=function(pos,listname,index,stack)
+	if listname=="fuel" then
+		local def=stack:get_definition()
+		return (def.groups and def.groups._industrialtest_fuel) and stack:get_count() or 0
+	end
+	if listname=="target" then
+		local def=stack:get_definition()
+		return (def.groups and def.groups._industrialtest_fueled) and stack:get_count() or 0
+	end
+	return stack:get_count()
+end
+
+canningMachine.allowMetadataInventoryTake=function(pos,listname,index,stack)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local fuelSlot=inv:get_stack("fuel",1)
+	local targetSlot=inv:get_stack("target",1)
+	if ((listname=="fuel" and stack:get_count()==fuelSlot:get_count()) or (listname=="target" and stack:get_count()==targetSlot:get_count())) and meta:get_float("srcTime")>0 then
+		meta:set_float("srcTime",0)
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	end
+	return stack:get_count()
+end
+
+canningMachine.onMetadataInventoryPut=function(pos)
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+end
+
+canningMachine.onMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local fuelSlot=inv:get_stack("fuel",1)
+	local targetSlot=inv:get_stack("target",1)
+	if ((fromList=="fuel" and count==fuelSlot:get_count()) or (fromList=="target" and count==targetSlot:get_count())) and meta:get_float("srcTime")>0 then
+		meta:set_float("srcTime",0)
+		meta:set_string("formspec",canningMachine.getFormspec(pos))
+	end
+end
+
+canningMachine.activeOnTimer=function(pos,elapsed,meta,inv)
+	local shouldUpdateFormspec=false
+	local fuelSlot=inv:get_stack("fuel",1)
+	local targetSlot=inv:get_stack("target",1)
+	local powerStorageSlot=inv:get_stack("powerStorage",1)
+
+	shouldRerunTimer,shouldUpdateFormspec=industrialtest.internal.chargeFromPowerStorageItem(meta,inv)
+
+	if fuelSlot:is_empty() or targetSlot:is_empty() or meta:get_int("industrialtest.powerAmount")<canningMachine.opPower then
+		if meta:get_int("industrialtest.powerAmount")>=canningMachine.opPower then
+			meta:set_float("srcTime",0)
+		end
+		minetest.swap_node(pos,{
 			name="industrialtest:canning_machine",
-	description=S("Canning Machine"),
+			param2=minetest.get_node(pos).param2
+		})
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		return false,true
+	end
+
+	local fuelMeta=fuelSlot:get_meta()
+	local targetMeta=targetSlot:get_meta()
+	if (industrialtest.api.itemHasFluidStorage(fuelSlot) and fuelMeta:get_int("industrialtest.fluidAmount")==0) or targetMeta:get_int("industrialtest.fluidAmount")==targetMeta:get_int("industrialtest.fluidCapacity") then
+		meta:set_float("srcTime",0)
+		minetest.swap_node(pos,{
+			name="industrialtest:canning_machine",
+			param2=minetest.get_node(pos).param2
+		})
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		return false,true
+	end
+
+	local srcTime=meta:get_float("srcTime")
+	srcTime=srcTime+elapsed*industrialtest.api.getMachineSpeed(meta)
+	if srcTime>=canningMachine.canningTime then
+		if industrialtest.api.itemHasFluidStorage(fuelSlot) then
+			industrialtest.api.transferFluidToItem(fuelSlot,targetSlot,fuelMeta:get_int("industrialtest.fluidAmount"))
+			inv:set_stack("fuel",1,fuelSlot)
+			inv:set_stack("target",1,targetSlot)
+		else
+			local def=fuelSlot:get_definition()
+			local leftoverSlot=inv:get_stack("leftover",1)
+			if targetMeta:get_int("industrialtest.fluidCapacity")-targetMeta:get_int("industrialtest.fluidAmount")<def._industrialtest_fuelAmount or (def._industrialtest_emptyVariant and not leftoverSlot:item_fits(ItemStack(def._industrialtest_emptyVariant))) then
+				minetest.swap_node(pos,{
+					name="industrialtest:canning_machine",
+					param2=minetest.get_node(pos).param2
+				})
+				minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+				return false,shouldUpdateFormspec
+			end
+			industrialtest.api.addFluidToItem(targetSlot,def._industrialtest_fuelAmount)
+			inv:set_stack("target",1,targetSlot)
+			fuelSlot:take_item(1)
+			inv:set_stack("fuel",1,fuelSlot)
+			leftoverSlot:add_item(ItemStack(def._industrialtest_emptyVariant))
+			inv:set_stack("leftover",1,leftoverSlot)
+		end
+		meta:set_float("srcTime",0)
+	else
+		meta:set_float("srcTime",srcTime)
+	end
+	industrialtest.api.addPower(meta,-canningMachine.opPower)
+
+	return true,true
+end
+
+industrialtest.internal.registerMachine({
+	name="canning_machine",
+	displayName=S("Canning Machine"),
+	capacity=industrialtest.api.lvPowerFlow*2,
+	getFormspec=canningMachine.getFormspec,
+	flow=industrialtest.api.lvPowerFlow,
+	ioConfig="iiiiii",
+	requiresWrench=true,
+	registerActiveVariant=true,
+	sounds="metal",
+	powerSlots={"powerStorage"},
+	storageSlots={"fuel","target","powerStorage","upgrades"},
+	groups={
+		_industrialtest_hasPowerInput=1
+	},
+	customKeys={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
@@ -27,22 +246,10 @@ industrialtest.internal.unpackTableInto(industrialtest.CanningMachine,{
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png^industrialtest_canning_machine_front.png"
 		},
-	sounds="metal",
+		paramtype2="facedir",
-	facedir=true,
+		legacy_facedir_simple=true
-	storageLists={
-		"src",
-		"dst",
-		"leftover",
-		"upgrades",
-		"powerStorage"
 	},
-	powerLists={
+	activeCustomKeys={
-		{
-			list="powerStorage",
-			direction="i"
-		}
-	},
-	active={
 		tiles={
 			"industrialtest_machine_block.png",
 			"industrialtest_machine_block.png",
@@ -52,194 +259,15 @@ industrialtest.internal.unpackTableInto(industrialtest.CanningMachine,{
 			"industrialtest_machine_block.png^industrialtest_canning_machine_front_active.png"
 		}
 	},
-	capacity=industrialtest.api.lvPowerFlow*2,
+	onConstruct=canningMachine.onConstruct,
-	flow=industrialtest.api.lvPowerFlow,
+	onTimer=canningMachine.onTimer,
-	ioConfig="iiiiii",
+	allowMetadataInventoryMove=canningMachine.allowMetadataInventoryMove,
-	requiresWrench=true,
+	allowMetadataInventoryPut=canningMachine.allowMetadataInventoryPut,
-	hasPowerInput=true,
+	allowMetadataInventoryTake=canningMachine.allowMetadataInventoryTake,
-	_opPower=200,
+	onMetadataInventoryPut=canningMachine.onMetadataInventoryPut,
-	_canningTime=5
+	onMetadataInventoryMove=canningMachine.onMetadataInventoryMove,
+	activeOnTimer=canningMachine.activeOnTimer
 })
-
-function industrialtest.CanningMachine.onConstruct(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	inv:set_size("src",1)
-	inv:set_size("dst",1)
-	inv:set_size("leftover",1)
-	inv:set_size("powerStorage",1)
-	inv:set_size("upgrades",4)
-	meta:set_float("srcTime",0)
-	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
-end
-
-function industrialtest.CanningMachine.getFormspec(self,pos)
-	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
-	local meta=minetest.get_meta(pos)
-	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
-	local srcPercent=meta:get_float("srcTime")/self._canningTime*100
-	local formspec={
-		"list[context;src;3.4,1.8;1,1]",
-		industrialtest.internal.getItemSlotBg(3.4,1.8,1,1),
-		(powerPercent>0 and "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
-		 or "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
-		"list[context;powerStorage;3.4,3.9;1,1]",
-		industrialtest.internal.getItemSlotBg(3.4,3.9,1,1),
-		(srcPercent>0 and "image[4.9,1.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
-		 or "image[4.9,1.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
-		"list[context;dst;6.4,1.8;1,1]",
-		industrialtest.internal.getItemSlotBg(6.4,1.8,1,1),
-		"list[context;leftover;6.4,2.8;1,1]",
-		industrialtest.internal.getItemSlotBg(6.4,2.8,1,1),
-		"list[context;upgrades;9,0.9;1,4]",
-		industrialtest.internal.getItemSlotBg(9,0.9,1,4),
-		"listring[context;src]",
-		"listring[context;dst]"
-	}
-	return parentFormspec..table.concat(formspec,"")
-end
-
-function industrialtest.CanningMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	if toList=="src" then
-		local inv=minetest.get_meta(pos):get_inventory()
-		local itemstack=inv:get_stack(fromList,fromIndex)
-		local def=itemstack:get_definition()
-		return (def.groups and def.groups._industrialtest_fuel) and count or 0
-	end
-	if toList=="dst" then
-		local inv=minetest.get_meta(pos):get_inventory()
-		local itemstack=inv:get_stack(fromList,fromIndex)
-		local def=itemstack:get_definition()
-		return (def.groups and def.groups._industrialtest_fueled) and count or 0
-	end
-	if toList=="leftover" then
-		return 0
-	end
-	return math.min(count,industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count))
-end
-
-function industrialtest.CanningMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
-	if listname=="src" then
-		local def=stack:get_definition()
-		return (def.groups and def.groups._industrialtest_fuel) and stack:get_count() or 0
-	end
-	if listname=="dst" then
-		local def=stack:get_definition()
-		return (def.groups and def.groups._industrialtest_fueled) and stack:get_count() or 0
-	end
-	if listname=="leftover" then
-		return 0
-	end
-	return math.min(stack:get_count(),industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player))
-end
-
-function industrialtest.CanningMachine.allowMetadataInventoryTake(self,pos,listname,index,stack,player)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local fuelSlot=inv:get_stack("src",1)
-	local targetSlot=inv:get_stack("dst",1)
-	if ((listname=="src" and stack:get_count()==fuelSlot:get_count()) or (listname=="dst" and stack:get_count()==targetSlot:get_count())) and meta:get_float("srcTime")>0 then
-		meta:set_float("srcTime",0)
-		self:updateFormspec(pos)
-	end
-	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryTake(self,pos,listname,index,stack,player)
-end
-
-function industrialtest.CanningMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local fuelSlot=inv:get_stack("src",1)
-	local targetSlot=inv:get_stack("dst",1)
-	if ((fromList=="src" and count==fuelSlot:get_count()) or (fromList=="dst" and count==targetSlot:get_count())) and meta:get_float("srcTime")>0 then
-		meta:set_float("srcTime",0)
-		self:updateFormspec(pos)
-	end
-end
-
-function industrialtest.CanningMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
-	self:triggerIfNeeded(pos)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
-end
-
-function industrialtest.CanningMachine.shouldActivate(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local fuelSlot=inv:get_stack("src",1)
-	local targetSlot=inv:get_stack("dst",1)
-	local leftoverSlot=inv:get_stack("leftover",1)
-	local powerStorageSlot=inv:get_stack("powerStorage",1)
-	local targetMeta=targetSlot:get_meta()
-	local def=fuelSlot:get_definition()
-
-	return not fuelSlot:is_empty() and not targetSlot:is_empty() and meta:get_int("industrialtest.powerAmount")>=self._opPower and (not def._industrialtest_emptyVariant or leftoverSlot:item_fits(ItemStack(def._industrialtest_emptyVariant))) and
-		(not industrialtest.api.itemHasFluidStorage(fuelSlot) or fuelSlot:get_meta():get_int("industrialtest.fluidAmount")>0) and targetMeta:get_int("industrialtest.fluidAmount")<targetMeta:get_int("industrialtest.fluidCapacity")
-end
-
-function industrialtest.CanningMachine.shouldDeactivate(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local fuelSlot=inv:get_stack("src",1)
-	local fuelDef=fuelSlot:get_definition()
-	local targetSlot=inv:get_stack("dst",1)
-	local targetMeta=targetSlot:get_meta()
-	local leftoverSlot=inv:get_stack("leftover",1)
-
-	return fuelSlot:is_empty() or targetSlot:is_empty() or meta:get_int("industrialtest.powerAmount")<self._opPower or
-		(industrialtest.api.itemHasFluidStorage(fuelSlot) and industrialtest.api.isItemFluidStorageEmpty(fuelSlot)) or
-		industrialtest.api.isItemFluidStorageFull(targetSlot) or
-		targetMeta:get_int("industrialtest.fluidCapacity")-targetMeta:get_int("industrialtest.fluidAmount")<(fuelDef._industrialtest_fuelAmount or 0) or
-		(fuelDef._industrialtest_emptyVariant and not leftoverSlot:item_fits(ItemStack(fuelDef._industrialtest_emptyVariant)))
-end
-
-function industrialtest.CanningMachine.afterDeactivation(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local targetSlot=inv:get_stack("dst",1)
-	if meta:get_int("industrialtest.powerAmount")>=self._opPower or industrialtest.api.isItemFluidStorageFull(targetSlot) then
-		meta:set_float("srcTime",0)
-	end
-	self:updateFormspec(pos)
-end
-
-function industrialtest.CanningMachine.activeUpdate(self,pos,elapsed,meta,inv)
-	local shouldUpdateFormspec=false
-	local fuelSlot=inv:get_stack("src",1)
-	local targetSlot=inv:get_stack("dst",1)
-	local powerStorageSlot=inv:get_stack("powerStorage",1)
-
-	local fuelMeta=fuelSlot:get_meta()
-	local targetMeta=targetSlot:get_meta()
-	local srcTime=meta:get_float("srcTime")+elapsed*industrialtest.api.getMachineSpeed(meta)
-	if srcTime>=self._canningTime then
-		if industrialtest.api.itemHasFluidStorage(fuelSlot) then
-			industrialtest.api.transferFluidToItem(fuelSlot,targetSlot,fuelMeta:get_int("industrialtest.fluidAmount"))
-			inv:set_stack("src",1,fuelSlot)
-			inv:set_stack("dst",1,targetSlot)
-		else
-			local def=fuelSlot:get_definition()
-			local leftoverSlot=inv:get_stack("leftover",1)
-			if targetMeta:get_int("industrialtest.fluidCapacity")-targetMeta:get_int("industrialtest.fluidAmount")<def._industrialtest_fuelAmount or (def._industrialtest_emptyVariant and not leftoverSlot:item_fits(ItemStack(def._industrialtest_emptyVariant))) then
-				return shouldUpdateFormspec
-			end
-			industrialtest.api.addFluidToItem(targetSlot,def._industrialtest_fuelAmount)
-			inv:set_stack("dst",1,targetSlot)
-			fuelSlot:take_item(1)
-			inv:set_stack("src",1,fuelSlot)
-			leftoverSlot:add_item(ItemStack(def._industrialtest_emptyVariant))
-			inv:set_stack("leftover",1,leftoverSlot)
-		end
-		meta:set_float("srcTime",0)
-	else
-		meta:set_float("srcTime",srcTime)
-	end
-	industrialtest.api.addPower(meta,-self._opPower)
-
-	return true
-end
-
-industrialtest.CanningMachine:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:canning_machine",

machines/chargepad.lua

@@ -15,71 +15,11 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
+
+local chargepad={}
 industrialtest.internal.chargepads={}
-industrialtest.Chargepad=table.copy(industrialtest.ActivatedElectricMachine)
-industrialtest.internal.unpackTableInto(industrialtest.Chargepad,{
-	storageLists={
-		"charged",
-		"discharged"
-	},
-	powerLists={
-		{
-			list="charged",
-			direction="o"
-		},
-		{
-			list="discharged",
-			direction="i"
-		}
-	},
-	facedir=true,
-	ioConfig="iiiioi",
-	hasPowerInput=true,
-	hasPowerOutput=true
-})
 
-function industrialtest.Chargepad.onConstruct(self,pos)
+local function chargePlayer(meta,player,flow)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	inv:set_size("charged",1)
-	inv:set_size("discharged",1)
-	meta:set_int("active",0)
-	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
-end
-
-function industrialtest.Chargepad.getFormspec(self,pos)
-	local meta=minetest.get_meta(pos)
-	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
-	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
-	local formspec={
-		"list[context;charged;1,2.5;1,1]",
-		industrialtest.internal.getItemSlotBg(1,2.5,1,1),
-		"label[0.9,3.9;"..S("Charge").."]",
-		"list[context;discharged;3,2.5;1,1]",
-		industrialtest.internal.getItemSlotBg(3,2.5,1,1),
-		"label[2.7,3.9;"..S("Discharge").."]",
-		self.createPowerIndicatorWidget(charged,9,1),
-		"listring[context;charged]",
-		"listring[context;discharged]"
-	}
-	return parentFormspec..table.concat(formspec,"")
-end
-
-function industrialtest.Chargepad.register(self)
-	industrialtest.ActivatedElectricMachine.register(self)
-	table.insert(industrialtest.internal.chargepads,self.name)
-	table.insert(industrialtest.internal.chargepads,self.name.."_active")
-	minetest.register_craft({
-		type="shaped",
-		output=self.name,
-		recipe={
-			{"industrialtest:electronic_circuit",industrialtest.elementKeys.stoneSlab,"industrialtest:electronic_circuit"},
-			{industrialtest.elementKeys.rubber,self._basePowerStorage,industrialtest.elementKeys.rubber}
-		}
-	})
-end
-
-function industrialtest.Chargepad.chargePlayer(meta,player,flow)
 	local inv
 	if industrialtest.mtgAvailable then
 		_,inv=armor:get_valid_player(player,"")
@@ -128,7 +68,45 @@ function industrialtest.Chargepad.chargePlayer(meta,player,flow)
 	return true
 end
 
-function industrialtest.Chargepad.action(self,pos,node)
+chargepad.getFormspec=function(pos)
+	local meta=minetest.get_meta(pos)
+	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
+	local formspec
+	if industrialtest.mtgAvailable then
+		formspec={
+			"list[context;charged;1,2.5;1,1]",
+			"listring[context;charged]",
+			"label[0.9,3.9;"..S("Charge").."]",
+			"list[context;discharged;3,2.5;1,1]",
+			"listring[context;discharged]",
+			"label[2.7,3.9;"..S("Discharge").."]",
+			"box[9,1;0.3,4.8;#202020]",
+			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or "")
+		}
+	elseif industrialtest.mclAvailable then
+		formspec={
+			"list[context;charged;1,2.5;1,1]",
+			"listring[context;charged]",
+			mcl_formspec.get_itemslot_bg(1,2.5,1,1),
+			"label[0.9,3.9;"..S("Charge").."]",
+			"list[context;discharged;3,2.5;1,1]",
+			"listring[context;discharged]",
+			mcl_formspec.get_itemslot_bg(3,2.5,1,1),
+			"label[2.7,3.9;"..S("Discharge").."]",
+			"box[9,1;0.3,4.8;#202020]",
+			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or "")
+		}
+	end
+	return table.concat(formspec,"")
+end
+
+chargepad.onConstruct=function(pos,meta,inv)
+	inv:set_size("charged",1)
+	inv:set_size("discharged",1)
+	meta:set_int("active",0)
+end
+
+chargepad.action=function(pos,node)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	local chargedSlot=inv:get_stack("charged",1)
@@ -152,149 +130,138 @@ function industrialtest.Chargepad.action(self,pos,node)
 	for _,player in ipairs(players) do
 		if vector.in_area(player:get_pos(),p1,p2) then
 			playerFound=true
-			shouldUpdateFormspec=shouldUpdateFormspec or self.chargePlayer(meta,player,flow)
+			shouldUpdateFormspec=shouldUpdateFormspec or chargePlayer(meta,player,flow)
 			break
 		end
 	end
 	local active=meta:get_int("active")==1
 	if playerFound and not active then
-		self:activate(pos)
+		minetest.swap_node(pos,{
+			name=node.name.."_active",
+			param2=node.param2
+		})
 		meta:set_int("active",1)
 	elseif (not playerFound or meta:get_int("industrialtest.powerAmount")==0) and active then
-		self:deactivate(pos)
+		local def=minetest.registered_nodes[node.name]
+		minetest.swap_node(pos,{
+			name=def._industrialtest_baseNodeName,
+			param2=node.param2
+		})
 		meta:set_int("active",0)
 	end
 
 	if shouldUpdateFormspec then
-		self:updateFormspec(pos)
+		local def=minetest.registered_nodes[node.name]
+		def._industrialtest_updateFormspec(pos)
 	end
 end
 
-industrialtest.BatboxChargepad=table.copy(industrialtest.Chargepad)
+local function registerChargepad(config)
-industrialtest.internal.unpackTableInto(industrialtest.BatboxChargepad,{
+	industrialtest.internal.registerMachine({
-	name="industrialtest:batbox_chargepad",
+		name=config.name,
-	description=S("BatBox Chargepad"),
+		displayName=config.displayName,
-	tiles={
+		capacity=config.capacity,
-		"industrialtest_wood_machine_block.png^industrialtest_chargepad_top.png",
+		flow=config.flow,
-		"industrialtest_wood_machine_block.png",
+		ioConfig="iiiioi",
-		"industrialtest_wood_machine_block.png",
+		sounds=config.sounds,
-		"industrialtest_wood_machine_block.png",
+		powerSlots={"charged","discharged"},
-		"industrialtest_wood_machine_block.png",
+		storageSlots={"charged","discharged"},
-		"industrialtest_wood_machine_block.png^industrialtest_batbox_front.png"
+		requiresWrench=config.requiresWrench,
+		registerActiveVariant=true,
+		groups={
+			_industrialtest_hasPowerOutput=1,
+			_industrialtest_hasPowerInput=1
 		},
-	sounds="wood",
+		customKeys={
-	active={
 			tiles={
-			"industrialtest_wood_machine_block.png^industrialtest_chargepad_top_active.png",
+				config.machineBlockTexture.."^industrialtest_chargepad_top.png",
-			"industrialtest_wood_machine_block.png",
+				config.machineBlockTexture,
-			"industrialtest_wood_machine_block.png",
+				config.machineBlockTexture,
-			"industrialtest_wood_machine_block.png",
+				config.machineBlockTexture,
-			"industrialtest_wood_machine_block.png",
+				config.machineBlockTexture,
-			"industrialtest_wood_machine_block.png^industrialtest_batbox_front.png"
+				config.machineBlockTexture.."^"..config.frontTexture
+			},
+			paramtype2="facedir",
+			legacy_facedir_simple=true
+		},
+		activeCustomKeys={
+			tiles={
+				config.machineBlockTexture.."^industrialtest_chargepad_top_active.png",
+				config.machineBlockTexture,
+				config.machineBlockTexture,
+				config.machineBlockTexture,
+				config.machineBlockTexture,
+				config.machineBlockTexture.."^"..config.frontTexture
+			},
+			_industrialtest_baseNodeName="industrialtest:"..config.name
+		},
+		getFormspec=chargepad.getFormspec,
+		onConstruct=chargepad.onConstruct
+	})
+	minetest.register_craft({
+		type="shaped",
+		output="industrialtest:"..config.name,
+		recipe={
+			{"industrialtest:electronic_circuit",industrialtest.elementKeys.stoneSlab,"industrialtest:electronic_circuit"},
+			{industrialtest.elementKeys.rubber,"industrialtest:"..config.basePowerStorage,industrialtest.elementKeys.rubber}
 		}
-	},
+	})
+	table.insert(industrialtest.internal.chargepads,"industrialtest:"..config.name)
+	table.insert(industrialtest.internal.chargepads,"industrialtest:"..config.name.."_active")
+end
+
+registerChargepad({
+	name="batbox_chargepad",
+	displayName=S("BatBox Chargepad"),
 	capacity=25000,
 	flow=industrialtest.api.lvPowerFlow,
-	_basePowerStorage="industrialtest:batbox"
+	sounds="wood",
+	machineBlockTexture="industrialtest_wood_machine_block.png",
+	frontTexture="industrialtest_batbox_front.png",
+	requiresWrench=false,
+	basePowerStorage="batbox"
 })
-industrialtest.BatboxChargepad:register()
 
-industrialtest.CESUChargepad=table.copy(industrialtest.Chargepad)
+registerChargepad({
-industrialtest.internal.unpackTableInto(industrialtest.CESUChargepad,{
+	name="cesu_chargepad",
-	name="industrialtest:cesu_chargepad",
+	displayName=S("CESU Chargepad"),
-	description=S("CESU Chargepad"),
-	tiles={
-		"industrialtest_bronze_machine_block.png^industrialtest_chargepad_top.png",
-		"industrialtest_bronze_machine_block.png",
-		"industrialtest_bronze_machine_block.png",
-		"industrialtest_bronze_machine_block.png",
-		"industrialtest_bronze_machine_block.png",
-		"industrialtest_bronze_machine_block.png^industrialtest_cesu_front.png"
-	},
-	sounds="metal",
-	active={
-		tiles={
-			"industrialtest_bronze_machine_block.png^industrialtest_chargepad_top_active.png",
-			"industrialtest_bronze_machine_block.png",
-			"industrialtest_bronze_machine_block.png",
-			"industrialtest_bronze_machine_block.png",
-			"industrialtest_bronze_machine_block.png",
-			"industrialtest_bronze_machine_block.png^industrialtest_cesu_front.png"
-		}
-	},
 	capacity=400000,
 	flow=industrialtest.api.mvPowerFlow,
-	_basePowerStorage="industrialtest:cesu"
-})
-industrialtest.CESUChargepad:register()
-
-industrialtest.MFEChargepad=table.copy(industrialtest.Chargepad)
-industrialtest.internal.unpackTableInto(industrialtest.MFEChargepad,{
-	name="industrialtest:mfe_chargepad",
-	description=S("MFE Chargepad"),
-	tiles={
-		"industrialtest_machine_block.png^industrialtest_chargepad_top.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_mfe_front.png"
-	},
 	sounds="metal",
-	requiresWrench=true,
+	machineBlockTexture="industrialtest_bronze_machine_block.png",
-	active={
+	frontTexture="industrialtest_cesu_front.png",
-		tiles={
+	requiresWrench=false,
-			"industrialtest_machine_block.png^industrialtest_chargepad_top_active.png",
+	basePowerStorage="cesu"
-			"industrialtest_machine_block.png",
+})
-			"industrialtest_machine_block.png",
+
-			"industrialtest_machine_block.png",
+registerChargepad({
-			"industrialtest_machine_block.png",
+	name="mfe_chargepad",
-			"industrialtest_machine_block.png^industrialtest_mfe_front.png"
+	displayName=S("MFE Chargepad"),
-		}
-	},
 	capacity=3000000,
 	flow=industrialtest.api.hvPowerFlow,
-	_basePowerStorage="industrialtest:mfe"
-})
-industrialtest.MFEChargepad:register()
-
-industrialtest.MFSUChargepad=table.copy(industrialtest.Chargepad)
-industrialtest.internal.unpackTableInto(industrialtest.MFSUChargepad,{
-	name="industrialtest:mfsu_chargepad",
-	description=S("MFSU Chargepad"),
-	tiles={
-		"industrialtest_advanced_machine_block.png^industrialtest_chargepad_top.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png^industrialtest_mfsu_front.png"
-	},
 	sounds="metal",
+	machineBlockTexture="industrialtest_machine_block.png",
+	frontTexture="industrialtest_mfe_front.png",
 	requiresWrench=true,
-	active={
+	basePowerStorage="mfe"
-		tiles={
+})
-			"industrialtest_advanced_machine_block.png^industrialtest_chargepad_top_active.png",
+
-			"industrialtest_advanced_machine_block.png",
+registerChargepad({
-			"industrialtest_advanced_machine_block.png",
+	name="mfsu_chargepad",
-			"industrialtest_advanced_machine_block.png",
+	displayName=S("MFSU Chargepad"),
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png^industrialtest_mfsu_front.png"
-		}
-	},
 	capacity=30000000,
 	flow=industrialtest.api.evPowerFlow,
-	_basePowerStorage="industrialtest:mfsu"
+	sounds="metal",
+	machineBlockTexture="industrialtest_advanced_machine_block.png",
+	frontTexture="industrialtest_mfsu_front.png",
+	requiresWrench=true,
+	basePowerStorage="mfsu"
 })
-industrialtest.MFSUChargepad:register()
 
 minetest.register_abm({
 	label="Chargepad updating",
 	nodenames=industrialtest.internal.chargepads,
-	interval=industrialtest.config.updateDelay,
+	interval=industrialtest.updateDelay,
 	chance=1,
-	action=function(pos,node)
+	action=chargepad.action
-		local def=minetest.registered_nodes[node.name]
-		def._industrialtest_self:action(pos,node)
-	end
 })

machines/common.lua

@@ -0,0 +1,785 @@
+-- IndustrialTest
+-- Copyright (C) 2023 mrkubax10
+
+-- This program is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+-- GNU General Public License for more details.
+
+-- You should have received a copy of the GNU General Public License
+-- along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+local machine={}
+local simpleElectricItemProcessor={}
+
+industrialtest.internal.simpleElectricItemProcessors={}
+
+industrialtest.internal.mclAfterDigNode=function(pos,oldmeta,lists)
+	-- Taken from https://git.minetest.land/MineClone2/MineClone2/src/branch/master/mods/ITEMS/mcl_furnaces/init.lua#L538
+	local meta=minetest.get_meta(pos)
+	local meta2=meta
+	meta:from_table(oldmeta)
+	local inv=meta:get_inventory()
+	for _,listname in ipairs(lists) do
+		local stack=inv:get_stack(listname,1)
+		if not stack:is_empty() then
+			local p = {x=pos.x+math.random(0, 10)/10-0.5, y=pos.y, z=pos.z+math.random(0, 10)/10-0.5}
+			minetest.add_item(p, stack)
+		end
+	end
+	meta:from_table(meta2:to_table())
+end
+
+industrialtest.internal.allowMoveToUpgradeSlot=function(pos,toIndex,stack)
+	local def=minetest.registered_items[stack:get_name()]
+	if not def or not def.groups or not def.groups._industrialtest_machineUpgrade then
+		return 0
+	end
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local targetSlot=inv:get_stack("upgrades",toIndex)
+	if not targetSlot:is_empty() then
+		return 0
+	end
+	return stack:get_count()
+end
+
+industrialtest.internal.chargeFromPowerStorageItem=function(meta,inv)
+	local shouldRerunTimer=false
+	local shouldUpdateFormspec=false
+	local powerStorageSlot=inv:get_stack("powerStorage",1)
+	if not powerStorageSlot:is_empty() then
+		local stackMeta=powerStorageSlot:get_meta()
+		if industrialtest.api.transferPower(stackMeta,meta,stackMeta:get_int("industrialtest.powerFlow"))>0 then
+			shouldUpdateFormspec=true
+			shouldRerunTimer=stackMeta:get_int("industrialtest.powerAmount")>0 and not industrialtest.api.isFullyCharged(meta)
+			industrialtest.api.updateItemPowerText(powerStorageSlot)
+			inv:set_stack("powerStorage",1,powerStorageSlot)
+		end
+	end
+	return shouldRerunTimer,shouldUpdateFormspec
+end
+
+machine.getFormspec=function(pos,config)
+	local formspec
+	if industrialtest.mtgAvailable then
+		formspec={
+			"formspec_version[4]",
+			"size[10.8,12]",
+			"label[0.5,0.5;"..config.displayName.."]",
+			(config.getFormspec and config.getFormspec(pos) or ""),
+			"list[current_player;main;0.5,6.25;8,1]",
+			"list[current_player;main;0.5,7.5;8,3;8]"
+		}
+	elseif industrialtest.mclAvailable then
+		formspec={
+			"size[10.04,12]",
+			"label[0.25,0.25;"..config.displayName.."]",
+			(config.getFormspec and config.getFormspec(pos) or ""),
+			"list[current_player;main;0.5,7;9,3;9]",
+			mcl_formspec.get_itemslot_bg(0.5,7,9,3),
+			"list[current_player;main;0.5,10.24;9,1]",
+			mcl_formspec.get_itemslot_bg(0.5,10.24,9,1)
+		}
+	end
+	return table.concat(formspec,"")
+end
+
+machine.onConstruct=function(pos,config)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+
+	industrialtest.api.addPowerStorage(meta,config.capacity,config.flow,config.ioConfig)
+
+	if config.groups then
+		if config.groups._industrialtest_hasPowerInput then
+			local connections=industrialtest.api.getConnections(pos)
+			for _,conn in ipairs(connections) do
+				local connectionMeta=minetest.get_meta(conn)
+				if industrialtest.api.isNetworkMaster(connectionMeta) then
+					industrialtest.api.createNetworkMapForNode(conn)
+					minetest.get_node_timer(conn):start(industrialtest.updateDelay)
+				else
+					local def=minetest.registered_nodes[minetest.get_node(conn).name]
+					if def.groups._industrialtest_cable then
+						local networks=industrialtest.api.isAttachedToNetwork(connectionMeta)
+						if networks then
+							for _,network in ipairs(networks) do
+								industrialtest.api.createNetworkMapForNode(network)
+								minetest.get_node_timer(network):start(industrialtest.updateDelay)
+							end
+						end
+					end
+				end
+			end
+		end
+		if config.groups._industrialtest_hasPowerOutput then
+			meta:set_string("industrialtest.network",minetest.serialize(industrialtest.api.createNetworkMap(pos)))
+		end
+	end
+
+	if config.onConstruct then
+		config.onConstruct(pos,meta,inv)
+	end
+
+	if not config.withoutFormspec then
+		meta:set_string("formspec",machine.getFormspec(pos,config))
+	end
+
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+end
+
+machine.onDestruct=function(pos,config)
+	local meta=minetest.get_meta(pos)
+	if industrialtest.api.isNetworkMaster(meta) then
+		local network=industrialtest.api.createNetworkMap(pos,true)
+		for _,endpoint in ipairs(network) do
+			local endpointMeta=minetest.get_meta(endpoint.position)
+			local networks=industrialtest.api.isAttachedToNetwork(endpointMeta)
+			for key,value in ipairs(networks) do
+				if value.x==pos.x and value.y==pos.y and value.z==pos.z then
+					table.remove(networks,key)
+					break
+				end
+			end
+			endpointMeta:set_string("industrialtest.networks",minetest.serialize(networks))
+		end
+	end
+	local networks=industrialtest.api.isAttachedToNetwork(meta)
+	if networks then
+		for _,network in ipairs(networks) do
+			industrialtest.api.removeNodeFromNetwork(network,pos)
+		end
+	end
+	if config.onDestruct then
+		config.onDestruct(pos)
+	end
+end
+
+machine.onTimer=function(pos,elapsed,config)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local shouldRerunTimer=false
+	local shouldUpdateFormspec=false
+
+	if config.onTimer then
+		shouldRerunTimer,shouldUpdateFormspec=config.onTimer(pos,elapsed,meta,inv)
+	end
+
+	local def=minetest.registered_nodes[minetest.get_node(pos).name]
+	if def.groups and def.groups._industrialtest_hasPowerInput and not industrialtest.api.isFullyCharged(meta) then
+		local networks=industrialtest.api.isAttachedToNetwork(meta)
+		if networks then
+			for _,network in ipairs(networks) do
+				minetest.get_node_timer(network):start(industrialtest.updateDelay)
+			end
+		end
+	end
+
+	if shouldUpdateFormspec then
+		machine.updateFormspec(pos,config)
+	end
+
+	return shouldRerunTimer
+end
+
+machine.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count,config)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local movedItemStack=inv:get_stack(fromList,1)
+
+	if toList=="upgrades" then
+		return industrialtest.internal.allowMoveToUpgradeSlot(pos,toIndex,movedItemStack)
+	end
+
+	local found=false
+	if config.powerSlots then
+		for _,value in ipairs(config.powerSlots) do
+			if value==toList then
+				found=true
+				break
+			end
+		end
+	end
+	if found and not industrialtest.api.hasPowerStorage(movedItemStack:get_meta()) then
+		return 0
+	end
+
+	if config.allowMetadataInventoryMove then
+		return config.allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count)
+	end
+
+	return count
+end
+
+machine.allowMetadataInventoryPut=function(pos,listname,index,stack,player,config)
+	if listname=="upgrades" then
+		return industrialtest.internal.allowMoveToUpgradeSlot(pos,index,stack)
+	end
+
+	local found=false
+	if config.powerSlots then
+		for _,value in ipairs(config.powerSlots) do
+			if value==listname then
+				found=true
+				break
+			end
+		end
+	end
+	if found and not industrialtest.api.hasPowerStorage(stack:get_meta()) then
+		return 0
+	end
+
+	if config.allowMetadataInventoryPut then
+		return config.allowMetadataInventoryPut(pos,listname,index,stack,player)
+	end
+
+	return stack:get_count()
+end
+
+machine.allowMetadataInventoryTake=function(pos,listname,index,stack,player,config)
+	if config.allowMetadataInventoryTake then
+		return config.allowMetadataInventoryTake(pos,listname,index,stack,player)
+	end
+	return stack:get_count()
+end
+
+machine.onMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
+	if toList=="upgrades" then
+		local meta=minetest.get_meta(pos)
+		local inv=meta:get_inventory()
+		local stack=inv:get_stack(fromList,fromIndex)
+		industrialtest.internal.applyUpgrade(pos,meta,stack)
+	elseif fromList=="upgrades" then
+		local meta=minetest.get_meta(pos)
+		local inv=meta:get_inventory()
+		local stack=inv:get_stack(fromList,fromIndex)
+		industrialtest.internal.removeUpgrade(pos,meta,stack)
+	end
+end
+
+machine.onMetadataInventoryPut=function(pos,listname,index,stack)
+	if listname=="upgrades" then
+		local meta=minetest.get_meta(pos)
+		industrialtest.internal.applyUpgrade(pos,meta,stack)
+	end
+end
+
+machine.onMetadataInventoryTake=function(pos,listname,index,stack)
+	if listname=="upgrades" then
+		local meta=minetest.get_meta(pos)
+		industrialtest.internal.removeUpgrade(pos,meta,stack)
+	end
+end
+
+machine.updateFormspec=function(pos,config)
+	if config.withoutFormspec then
+		return
+	end
+	local meta=minetest.get_meta(pos)
+	meta:set_string("formspec",machine.getFormspec(pos,config))
+end
+
+function industrialtest.internal.registerMachine(config)
+	local definition={
+		description=config.displayName,
+		on_construct=function(pos)
+			machine.onConstruct(pos,config)
+		end,
+		on_destruct=function(pos)
+			machine.onDestruct(pos,config)
+		end,
+		on_timer=function(pos,elapsed)
+			local shouldRerunTimer,_=machine.onTimer(pos,elapsed,config)
+			return shouldRerunTimer
+		end,
+		allow_metadata_inventory_move=function(pos,fromList,fromIndex,toList,toIndex,count)
+			return machine.allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count,config)
+		end,
+		allow_metadata_inventory_put=function(pos,listname,index,stack,player)
+			return machine.allowMetadataInventoryPut(pos,listname,index,stack,player,config)
+		end,
+		allow_metadata_inventory_take=function(pos,listname,index,stack,player)
+			return machine.allowMetadataInventoryTake(pos,listname,index,stack,player,config)
+		end,
+		on_metadata_inventory_put=function(pos,listname,index,stack,player)
+			machine.onMetadataInventoryPut(pos,listname,index,stack)
+			if config.onMetadataInventoryPut then
+				config.onMetadataInventoryPut(pos,listname,index,stack,player)
+			end
+		end,
+		on_metadata_inventory_move=function(pos,fromList,fromIndex,toList,toIndex,count)
+			machine.onMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex)
+			if config.onMetadataInventoryPut then
+				config.onMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count)
+			end
+		end,
+		on_metadata_inventory_take=function(pos,listname,index,stack,player)
+			machine.onMetadataInventoryTake(pos,listname,index,stack)
+			if config.onMetadataInventoryTake then
+				config.onMetadataInventoryTake(pos,listname,index,stack,player)
+			end
+		end,
+		_industrialtest_updateFormspec=function(pos)
+			machine.updateFormspec(pos,config)
+		end,
+		_industrialtest_getFormspec=function(pos)
+			if config.withoutFormspec then
+				return ""
+			end
+			return machine.getFormspec(pos,config)
+		end
+	}
+	if industrialtest.mtgAvailable then
+		definition.groups={cracky=2}
+		if config.sounds=="metal" then
+			definition.sounds=default.node_sound_metal_defaults()
+		end
+		definition.can_dig=function(pos)
+			local meta=minetest.get_meta(pos)
+			local inv=meta:get_inventory()
+			for _,value in ipairs(config.storageSlots) do
+				if inv:get_stack(value,1):get_count()>0 then
+					return false
+				end
+			end
+			return true
+		end
+	elseif industrialtest.mclAvailable then
+		definition.after_dig_node=function(pos,oldnode,oldmeta)
+			industrialtest.internal.mclAfterDigNode(pos,oldmeta,config.storageSlots)
+		end
+		if config.sounds=="metal" then
+			definition.sounds=mcl_sounds.node_sound_metal_defaults()
+		end
+		definition.groups={pickaxey=1}
+		definition._mcl_blast_resistance=3.5
+		definition._mcl_hardness=3.9
+	end
+	definition.groups._industrialtest_wrenchUnmountable=1
+	if config.requiresWrench then
+		definition.drop="industrialtest:machine_block"
+	end
+	if config.customKeys then
+		for key,value in pairs(config.customKeys) do
+			definition[key]=value
+		end
+	end
+	if config.groups then
+		for key,value in pairs(config.groups) do
+			definition.groups[key]=value
+		end
+	end
+	minetest.register_node("industrialtest:"..config.name,definition)
+	if config.registerActiveVariant then
+		definition=table.copy(definition)
+		definition.description=nil
+		definition.on_timer=function(pos,elapsed)
+			local meta=minetest.get_meta(pos)
+			local inv=meta:get_inventory()
+			local shouldRerunTimer=false
+			local shouldUpdateFormspec=false
+
+			if config.activeOnTimer then
+				shouldRerunTimer,shouldUpdateFormspec=config.activeOnTimer(pos,elapsed,meta,inv)
+			end
+
+			local def=minetest.registered_nodes[minetest.get_node(pos).name]
+			if def.groups and def.groups._industrialtest_hasPowerInput and not industrialtest.api.isFullyCharged(meta) then
+				local networks=industrialtest.api.isAttachedToNetwork(meta)
+				if networks then
+					for _,network in ipairs(networks) do
+						minetest.get_node_timer(network):start(industrialtest.updateDelay)
+					end
+				end
+			end
+
+			if shouldUpdateFormspec then
+				machine.updateFormspec(pos,config)
+			end
+
+			return shouldRerunTimer
+		end
+		if not definition.drop then
+			definition.drop="industrialtest:"..config.name
+		end
+		if config.activeCustomKeys then
+			for key,value in pairs(config.activeCustomKeys) do
+				definition[key]=value
+			end
+		end
+		if industrialtest.mclAvailable then
+			definition.groups.not_in_creative_inventory=1
+			definition._doc_items_create_entry=false
+		end
+		minetest.register_node("industrialtest:"..config.name.."_active",definition)
+	end
+end
+
+local function craftResultProxy(method,item)
+	if method=="cooking" then
+		local output,after=minetest.get_craft_result({
+			method=method,
+			width=1,
+			items={item}
+		})
+		return {
+			item=output.item,
+			time=output.time,
+			src=after.items[1]
+		}
+	elseif method=="industrialtest.macerating" then
+		local output=industrialtest.api.getMaceratorRecipeResult(item:get_name())
+		if not output then
+			return {
+				item=ItemStack(),
+				time=0,
+				src=item
+			}
+		end
+		local srcAfter=ItemStack(item:get_name())
+		srcAfter:set_count(item:get_count()-1)
+		return {
+			item=ItemStack(output.output),
+			time=output.time,
+			src=srcAfter
+		}
+	elseif method=="industrialtest.compressing" then
+		local output=industrialtest.api.getCompressorRecipeResult(item:get_name())
+		if not output or item:get_count()<output.count then
+			return {
+				item=ItemStack(),
+				time=0,
+				src=item
+			}
+		end
+		local srcAfter=ItemStack(item:get_name())
+		srcAfter:set_count(item:get_count()-output.count)
+		return {
+			item=ItemStack(output.output),
+			time=output.time,
+			src=srcAfter
+		}
+	elseif method=="industrialtest.extracting" then
+		local output=industrialtest.api.getExtractorRecipeResult(item:get_name())
+		if not output then
+			return {
+				item=ItemStack(),
+				time=0,
+				src=item
+			}
+		end
+		local srcAfter=ItemStack(item:get_name())
+		srcAfter:set_count(item:get_count()-1)
+		return {
+			item=ItemStack(output.output),
+			time=output.time,
+			src=srcAfter
+		}
+	elseif method=="industrialtest.recycling" then
+		local srcAfter=ItemStack(item:get_name())
+		srcAfter:set_count(item:get_count()-1)
+		return {
+			item=ItemStack(industrialtest.random:next(1,8)==1 and "industrialtest:scrap" or ""),
+			time=2,
+			src=srcAfter
+		}
+	elseif method=="industrialtest.cable_forming" then
+		local output=industrialtest.api.getCableFormerRecipeResult(item:get_name())
+		if not output then
+			return {
+				item=ItemStack(),
+				time=0,
+				src=item
+			}
+		end
+		local srcAfter=ItemStack(item:get_name())
+		srcAfter:set_count(item:get_count()-1)
+		return {
+			item=ItemStack(output.output),
+			time=output.time,
+			src=srcAfter
+		}
+	elseif method=="industrialtest.mass_fabricating" then
+		if item:get_count()<34 then
+			return {
+				item=ItemStack(),
+				time=0,
+				src=item
+			}
+		end
+		local srcAfter=ItemStack(item:get_name())
+		srcAfter:set_count(item:get_count()-34)
+		return {
+			item=ItemStack("industrialtest:uu_matter"),
+			time=15,
+			src=srcAfter
+		}
+	end
+	error("Unknown craft method passed to craftResultProxy")
+end
+
+simpleElectricItemProcessor.getFormspec=function(pos)
+	local meta=minetest.get_meta(pos)
+	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
+	local srcPercent=meta:get_float("srcTime")/meta:get_float("maxSrcTime")*100
+	local formspec
+	if industrialtest.mtgAvailable then
+		formspec={
+			"list[context;src;3.4,1.8;1,1]",
+			"listring[context;src]",
+			(powerPercent>0 and "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
+			 or "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
+			"list[context;powerStorage;3.4,3.9;1,1]",
+			"listring[context;powerStorage]",
+			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
+			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
+			"list[context;dst;6.4,2.8;1,1]",
+			"listring[context;dst]",
+			"list[context;upgrades;9,0.9;1,4]",
+			"listring[context;upgrades]"
+		}
+	elseif industrialtest.mclAvailable then
+		formspec={
+			"list[context;src;3.4,1.8;1,1]",
+			mcl_formspec.get_itemslot_bg(3.4,1.8,1,1),
+			"listring[context;src]",
+			(powerPercent>0 and "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
+			 or "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
+			"list[context;powerStorage;3.4,3.9;1,1]",
+			mcl_formspec.get_itemslot_bg(3.4,3.9,1,1),
+			"listring[context;powerStorage]",
+			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
+			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
+			"list[context;dst;6.4,2.8;1,1]",
+			mcl_formspec.get_itemslot_bg(6.4,2.8,1,1),
+			"listring[context;dst]",
+			"list[context;upgrades;9,0.9;1,4]",
+			mcl_formspec.get_itemslot_bg(9,0.9,1,4),
+			"listring[context;upgrades]"
+		}
+	end
+	return table.concat(formspec,"")
+end
+
+simpleElectricItemProcessor.onPowerFlow=function(pos)
+	-- FIXME: this probably will require refactor so node timer won't be started
+	-- just to test if machine can process item
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+end
+
+simpleElectricItemProcessor.onConstruct=function(pos,meta,inv)
+	inv:set_size("src",1)
+	inv:set_size("dst",1)
+	inv:set_size("powerStorage",1)
+	inv:set_size("upgrades",4)
+	meta:set_float("srcTime",-1)
+	meta:set_float("maxSrcTime",0)
+end
+
+simpleElectricItemProcessor.onTimer=function(pos,elapsed,meta,inv,config)
+	local srcSlot=inv:get_stack("src",1)
+	local powerStorageSlot=inv:get_stack("powerStorage",1)
+	local shouldUpdateFormspec=false
+	local shouldRerunTimer=false
+	local requiredPower=elapsed*config.opPower*industrialtest.api.getMachineSpeed(meta)
+
+	shouldRerunTimer,shouldUpdateFormspec=industrialtest.internal.chargeFromPowerStorageItem(meta,inv)
+
+	if srcSlot:get_count()>0 and meta:get_int("industrialtest.powerAmount")>=requiredPower then
+		local output=craftResultProxy(config.method,srcSlot)
+		if output.time>0 and inv:room_for_item("dst",output.item) then
+			if meta:get_float("maxSrcTime")<=0 then
+				meta:set_float("srcTime",0)
+				meta:set_float("maxSrcTime",output.time*config.efficiency)
+			end
+			minetest.swap_node(pos,{
+				name="industrialtest:"..config.name.."_active",
+				param2=minetest.get_node(pos).param2
+			})
+			minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		end
+	end
+	return shouldRerunTimer,shouldUpdateFormspec
+end
+
+simpleElectricItemProcessor.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,count)
+	if toList=="dst" then
+		return 0
+	elseif toList=="upgrades" then
+		-- TODO: Add support for upgrades when they will be added
+		return 0
+	end
+	return count
+end
+
+simpleElectricItemProcessor.allowMetadataInventoryPut=function(pos,listname,index,stack)
+	if listname=="dst" then
+		return 0
+	elseif listname=="src" then
+		local meta=minetest.get_meta(pos)
+		local inv=meta:get_inventory()
+		local srcSlot=inv:get_stack("src",1)
+		if srcSlot:get_name()~=stack:get_name() then
+			meta:set_float("srcTime",-1)
+			meta:set_float("maxSrcTime",0)
+		end
+	elseif listname=="upgrades" then
+		--TODO: See allow_metadata_inventory_move
+		return 0
+	end
+	return stack:get_count()
+end
+
+simpleElectricItemProcessor.onMetadataInventoryPut=function(pos)
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+end
+
+simpleElectricItemProcessor.onMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local srcSlot=inv:get_stack("src",1)
+	local dstSlot=inv:get_stack("dst",1)
+	if fromList=="src" and count==srcSlot:get_count() then
+		meta:set_float("srcTime",-1)
+		meta:set_float("maxSrcTime",0)
+		if meta:get_int("industrialtest.powerAmount")>0 then
+			meta:set_string("formspec",simpleElectricItemProcessor.getFormspec(pos))
+		end
+	elseif fromList=="dst" and dstSlot:get_free_space()>0 then
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	end
+end
+
+simpleElectricItemProcessor.onMetadataInventoryTake=function(pos,listname,index,stack)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local srcSlot=inv:get_stack("src",1)
+	local dstSlot=inv:get_stack("dst",1)
+	if listname=="src" and stack:get_count()==srcSlot:get_count() then
+		meta:set_float("srcTime",-1)
+		meta:set_float("maxSrcTime",0)
+		if meta:get_int("industrialtest.powerAmount")>0 then
+			meta:set_string("formspec",simpleElectricItemProcessor.getFormspec(pos))
+		end
+	elseif listname=="dst" and dstSlot:get_free_space()>0 then
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	end
+end
+
+simpleElectricItemProcessor.activeOnTimer=function(pos,elapsed,meta,inv,config)
+	local srcSlot=inv:get_stack("src",1)
+	local powerStorageSlot=inv:get_stack("powerStorage",1)
+	local shouldUpdateFormspec=false
+	local shouldRerunTimer=false
+	local requiredPower=elapsed*config.opPower*industrialtest.api.getMachineSpeed(meta)
+
+	shouldRerunTimer,shouldUpdateFormspec=industrialtest.internal.chargeFromPowerStorageItem(meta,inv)
+
+	if srcSlot:get_count()>0 and meta:get_float("maxSrcTime")<=0 and meta:get_int("industrialtest.powerAmount")>=requiredPower then
+		local output=craftResultProxy(config.method,srcSlot)
+		if output.time>0 and inv:room_for_item("dst",output.item) then
+			meta:set_float("srcTime",0)
+			meta:set_float("maxSrcTime",output.time*config.efficiency)
+		end
+	end
+	if srcSlot:get_count()==0 and meta:get_float("maxSrcTime")>0 then
+		meta:set_float("srcTime",-1)
+		meta:set_float("maxSrcTime",0)
+		shouldUpdateFormspec=true
+	end
+	if meta:get_float("maxSrcTime")>0 then
+		if meta:get_int("industrialtest.powerAmount")>=requiredPower then
+			meta:set_int("industrialtest.powerAmount",meta:get_int("industrialtest.powerAmount")-requiredPower)
+			meta:set_float("srcTime",meta:get_float("srcTime")+elapsed)
+			shouldRerunTimer=true
+		end
+		shouldUpdateFormspec=true
+	end
+	if meta:get_float("maxSrcTime")<=0 or meta:get_int("industrialtest.powerAmount")<requiredPower then
+		minetest.swap_node(pos,{
+			name="industrialtest:"..config.name,
+			param2=minetest.get_node(pos).param2
+		})
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	end
+	if meta:get_float("srcTime")>=meta:get_float("maxSrcTime") then
+		local output=craftResultProxy(config.method,srcSlot)
+		local speed=industrialtest.api.getMachineSpeed(meta)
+		local usedItems=srcSlot:get_count()-output.src:get_count()
+		local multiplier=1
+		if srcSlot:get_count()>=speed*usedItems then
+			multiplier=speed
+		end
+		if output.item:get_count()>0 then
+			output.item:set_count(output.item:get_count()*multiplier)
+			inv:add_item("dst",output.item)
+			meta:set_float("srcTime",-1)
+			meta:set_float("maxSrcTime",0)
+		end
+		srcSlot:set_count(srcSlot:get_count()-multiplier*usedItems)
+		inv:set_stack("src",1,srcSlot)
+	end
+	return shouldRerunTimer,shouldUpdateFormspec
+end
+
+function industrialtest.internal.registerSimpleElectricItemProcessor(config)
+	local machineBlockTexture=config.machineBlockTexture or "industrialtest_machine_block.png"
+	industrialtest.internal.registerMachine({
+		name=config.name,
+		displayName=config.displayName,
+		capacity=config.capacity,
+		getFormspec=simpleElectricItemProcessor.getFormspec,
+		flow=config.flow,
+		ioConfig="iiiiii",
+		requiresWrench=config.requiresWrench,
+		registerActiveVariant=true,
+		sounds="metal",
+		powerSlots={"powerStorage"},
+		storageSlots={"src","dst","powerStorage","upgrades"},
+		groups={
+			_industrialtest_hasPowerInput=1
+		},
+		customKeys={
+			tiles={
+				machineBlockTexture..(config.customTopTexture and "^industrialtest_"..config.name.."_top.png" or ""),
+				machineBlockTexture..(config.customBottomTexture and "^industrialtest_"..config.name.."_bottom.png" or ""),
+				machineBlockTexture..(config.customRightTexture and "^industrialtest_"..config.name.."_right.png" or ""),
+				machineBlockTexture..(config.customLeftTexture and "^industrialtest_"..config.name.."_left.png" or ""),
+				machineBlockTexture..(config.customBackTexture and "^industrialtest_"..config.name.."_back.png" or ""),
+				machineBlockTexture..(config.customFrontTexture and "^industrialtest_"..config.name.."_front.png" or "")
+			},
+			paramtype2="facedir",
+			legacy_facedir_simple=true,
+			_industrialtest_onPowerFlow=simpleElectricItemProcessor.onPowerFlow
+		},
+		activeCustomKeys={
+			tiles={
+				machineBlockTexture..(config.customTopTexture and "^industrialtest_"..config.name.."_top_active.png" or ""),
+				machineBlockTexture..(config.customBottomTexture and "^industrialtest_"..config.name.."_bottom_active.png" or ""),
+				machineBlockTexture..(config.customRightTexture and "^industrialtest_"..config.name.."_right_active.png" or ""),
+				machineBlockTexture..(config.customLeftTexture and "^industrialtest_"..config.name.."_left_active.png" or ""),
+				machineBlockTexture..(config.customBackTexture and "^industrialtest_"..config.name.."_back_active.png" or ""),
+				machineBlockTexture..(config.customFrontTexture and "^industrialtest_"..config.name.."_front_active.png" or "")
+			}
+		},
+		onConstruct=simpleElectricItemProcessor.onConstruct,
+		onTimer=function(pos,elapsed,meta,inv)
+			return simpleElectricItemProcessor.onTimer(pos,elapsed,meta,inv,config)
+		end,
+		allowMetadataInventoryMove=simpleElectricItemProcessor.allowMetadataInventoryMove,
+		allowMetadataInventoryPut=simpleElectricItemProcessor.allowMetadataInventoryPut,
+		onMetadataInventoryPut=simpleElectricItemProcessor.onMetadataInventoryPut,
+		onMetadataInventoryMove=simpleElectricItemProcessor.onMetadataInventoryMove,
+		onMetadataInventoryTake=simpleElectricItemProcessor.onMetadataInventoryTake,
+		activeOnTimer=function(pos,elapsed,meta,inv)
+			return simpleElectricItemProcessor.activeOnTimer(pos,elapsed,meta,inv,config)
+		end
+	})
+	table.insert(industrialtest.internal.simpleElectricItemProcessors,"industrialtest:"..config.name)
+end

machines/compressor.lua

@@ -15,55 +15,18 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.Compressor=table.copy(industrialtest.SimpleElectricItemProcessor)
+
-industrialtest.internal.unpackTableInto(industrialtest.Compressor,{
+industrialtest.internal.registerSimpleElectricItemProcessor({
-	name="industrialtest:compressor",
+	name="compressor",
-	description=S("Compressor"),
+	displayName=S("Compressor"),
-	tiles={
+	customFrontTexture=true,
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_compressor_front.png"
-	},
 	requiresWrench=true,
-	active={
-		tiles={
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png^industrialtest_compressor_front_active.png"
-		}
-	},
 	capacity=1400,
 	flow=industrialtest.api.lvPowerFlow,
 	opPower=120,
+	method="industrialtest.compressing",
 	efficiency=1
 })
-
-function industrialtest.Compressor.getCraftResult(self,itemstack)
-	local output=industrialtest.api.getCompressorRecipeResult(itemstack:get_name())
-	if not output or itemstack:get_count()<output.count then
-		return {
-			item=ItemStack(),
-			time=0,
-			src=itemstack
-		}
-	end
-	local srcAfter=ItemStack(itemstack:get_name())
-	srcAfter:set_count(itemstack:get_count()-output.count)
-	return {
-		item=ItemStack(output.output),
-		time=output.time,
-		src=srcAfter
-	}
-end
-
-industrialtest.Compressor:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:compressor",

machines/electric_furnace.lua

@@ -15,49 +15,17 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.ElectricFurnace=table.copy(industrialtest.SimpleElectricItemProcessor)
+
-industrialtest.internal.unpackTableInto(industrialtest.ElectricFurnace,{
+industrialtest.internal.registerSimpleElectricItemProcessor({
-	name="industrialtest:electric_furnace",
+	name="electric_furnace",
-	description=S("Electric Furnace"),
+	displayName=S("Electric Furnace"),
-	tiles={
+	customFrontTexture=true,
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_electric_furnace_front.png"
-	},
-	active={
-		tiles={
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png^industrialtest_electric_furnace_front_active.png"
-		}
-	},
 	capacity=416,
 	flow=industrialtest.api.lvPowerFlow,
 	opPower=60,
+	method="cooking",
 	efficiency=0.5
 })
-
-function industrialtest.ElectricFurnace.getCraftResult(self,itemstack)
-	local output,after=minetest.get_craft_result({
-		method="cooking",
-		width=1,
-		items={itemstack}
-	})
-	return {
-		item=output.item,
-		time=output.time,
-		src=after.items[1]
-	}
-end
-
-industrialtest.ElectricFurnace:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:electric_furnace",

machines/electric_machine.lua

@@ -1,243 +0,0 @@
--- IndustrialTest
--- Copyright (C) 2024 mrkubax10
-
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
-
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
-
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-industrialtest.ElectricMachine=table.copy(industrialtest.Machine)
-
-function industrialtest.ElectricMachine.onConstruct(self,pos)
-	local meta=minetest.get_meta(pos)
-
-	industrialtest.api.addPowerStorage(meta,self.capacity,self.flow,self.ioConfig)
-
-	if self.hasPowerInput then
-		local connections=industrialtest.api.getConnections(pos)
-		for _,conn in ipairs(connections) do
-			local connectionMeta=minetest.get_meta(conn)
-			if industrialtest.api.isNetworkMaster(connectionMeta) then
-				industrialtest.api.createNetworkMapForNode(conn)
-				local def=minetest.get_node(conn)
-				if def and def._industrialtest_self then
-					def._industrialtest_self:flowPower(conn)
-				else
-					-- Support for bare definitions that don't use industrialtest pseudo-OOP
-					minetest.get_node_timer(conn):start(industrialtest.config.updateDelay)
-				end
-			else
-				local def=minetest.registered_nodes[minetest.get_node(conn).name]
-				if def.groups._industrialtest_cable then
-					local networks=industrialtest.api.isAttachedToNetwork(connectionMeta)
-					if networks then
-						for _,network in ipairs(networks) do
-							industrialtest.api.createNetworkMapForNode(network)
-							local def=minetest.registered_nodes[minetest.get_node(network).name]
-							if def and def._industrialtest_self then
-								def._industrialtest_self:flowPower(network)
-							else
-								-- Support for bare definitions that don't use industrialtest pseudo-OOP
-								minetest.get_node_timer(network):start(industrialtest.config.updateDelay)
-							end
-						end
-					end
-				end
-			end
-		end
-	end
-	if self.hasPowerOutput then
-		meta:set_string("industrialtest.network",minetest.serialize(industrialtest.api.createNetworkMap(pos)))
-	end
-
-	industrialtest.Machine.onConstruct(self,pos)
-end
-
-function industrialtest.ElectricMachine.onDestruct(self,pos)
-	local meta=minetest.get_meta(pos)
-
-	if industrialtest.api.isNetworkMaster(meta) then
-		local network=industrialtest.api.createNetworkMap(pos,true)
-		for _,endpoint in ipairs(network) do
-			local endpointMeta=minetest.get_meta(endpoint.position)
-			local networks=industrialtest.api.isAttachedToNetwork(endpointMeta)
-			for key,value in ipairs(networks) do
-				if value.x==pos.x and value.y==pos.y and value.z==pos.z then
-					table.remove(networks,key)
-					break
-				end
-			end
-			endpointMeta:set_string("industrialtest.networks",minetest.serialize(networks))
-		end
-	end
-	local networks=industrialtest.api.isAttachedToNetwork(meta)
-	if networks then
-		for _,network in ipairs(networks) do
-			industrialtest.api.removeNodeFromNetwork(network,pos)
-		end
-	end
-
-	-- don't call onDestruct from parent class because it doesn't do anything
-end
-
-function industrialtest.ElectricMachine.onTimer(self,pos,elapsed)
-	local result=industrialtest.Machine.onTimer(self,pos,elapsed)
-	local result2=self:powerExchange(pos)
-	return result or result2
-end
-
-function industrialtest.ElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	local found=false
-	if self.powerLists then
-		for _,value in ipairs(self.powerLists) do
-			if value.list==toList then
-				found=true
-				break
-			end
-		end
-	end
-	if found and not industrialtest.api.hasPowerStorage(movedItemStack:get_meta()) then
-		return 0
-	end
-
-	return industrialtest.Machine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-end
-
-function industrialtest.ElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
-	local found=false
-	if self.powerLists then
-		for _,value in ipairs(self.powerLists) do
-			if value.list==listname then
-				found=true
-				break
-			end
-		end
-	end
-	if found and not industrialtest.api.hasPowerStorage(stack:get_meta()) then
-		return 0
-	end
-
-	return industrialtest.Machine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
-end
-
-function industrialtest.ElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	if self.powerLists then
-		for _,value in ipairs(self.powerLists) do
-			if value.list==toList then
-				self:trigger(pos)
-				break
-			end
-		end
-	end
-	industrialtest.Machine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-end
-
-function industrialtest.ElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
-	if self.powerLists then
-		for _,value in ipairs(self.powerLists) do
-			if value.list==listname then
-				self:trigger(pos)
-				break
-			end
-		end
-	end
-	industrialtest.Machine.onMetadataInventoryPut(self,pos,listname,index,stack)
-end
-
-function industrialtest.ElectricMachine.flowPower(self,pos)
-	if not self.hasPowerOutput then
-		return
-	end
-	local meta=minetest.get_meta(pos)
-	if meta:get_int("industrialtest.powerAmount")<=0 then
-		return
-	end
-	local _,flowTransferred=industrialtest.api.powerFlow(pos)
-	if flowTransferred then
-		self:updateFormspec(pos)
-	end
-	self:triggerIfNeeded(pos)
-end
-
-function industrialtest.ElectricMachine.requestPower(self,pos)
-	local meta=minetest.get_meta(pos)
-	local networks=industrialtest.api.isAttachedToNetwork(meta)
-	if networks then
-		for _,network in ipairs(networks) do
-			local def=minetest.registered_nodes[minetest.get_node(network).name]
-			if def and def._industrialtest_self then
-				def._industrialtest_self:flowPower(network)
-			else
-				-- Support for bare definitions that don't use industrialtest pseudo-OOP
-				minetest.get_node_timer(network):start(industrialtest.config.updateDelay)
-			end
-		end
-	end
-end
-
-function industrialtest.ElectricMachine.powerExchange(self,pos)
-	local meta=minetest.get_meta(pos)
-	local shouldRerunTimer=false
-
-	if self.hasPowerInput and not industrialtest.api.isFullyCharged(meta) then
-		self:requestPower(pos)
-		shouldRerunTimer=shouldRerunTimer or not industrialtest.api.isFullyCharged(meta)
-	end
-
-	if self.hasPowerOutput and meta:get_int("industrialtest.powerAmount")>0 then
-		local spaceAvailable,flowTransferred=industrialtest.api.powerFlow(pos)
-		if flowTransferred then
-			self:updateFormspec(pos)
-		end
-		shouldRerunTimer=shouldRerunTimer or spaceAvailable
-	end
-
-	if self.powerLists then
-		local inv=meta:get_inventory()
-		local powerFlow=meta:get_int("industrialtest.powerFlow")
-		for _,listDesc in ipairs(self.powerLists) do
-			local slot=inv:get_stack(listDesc.list,1)
-			if slot:get_count()>0 then
-				if listDesc.direction=="o" then
-					if meta:get_int("industrialtest.powerAmount")<=0 then
-						break
-					end
-					if not industrialtest.api.isFullyCharged(slot:get_meta()) then
-						industrialtest.api.transferPowerToItem(meta,slot,powerFlow)
-						inv:set_stack(listDesc.list,1,slot)
-						self:updateFormspec(pos)
-						shouldRerunTimer=shouldRerunTimer or (not industrialtest.api.isFullyCharged(slot:get_meta()) and meta:get_int("industrialtest.powerAmount")>0)
-					end
-				elseif listDesc.direction=="i" then
-					if industrialtest.api.isFullyCharged(meta) then
-						break
-					end
-					local slotMeta=slot:get_meta()
-					if slotMeta:get_int("industrialtest.powerAmount")>0 then
-						industrialtest.api.transferPowerFromItem(slot,meta,powerFlow)
-						inv:set_stack(listDesc.list,1,slot)
-						self:updateFormspec(pos)
-						shouldRerunTimer=shouldRerunTimer or (not industrialtest.api.isFullyCharged(meta) and slotMeta:get_int("industrialtest.powerAmount")>0)
-					end
-				end
-			end
-		end
-	end
-
-	return shouldRerunTimer
-end
-
-function industrialtest.ElectricMachine.createPowerIndicatorWidget(charged,x,y)
-	return table.concat({
-		string.format("box[%f,%f;0.3,4.8;#202020]",x,y),
-		(charged>0 and string.format("box[%f,%f;0.3,%f;#FF1010]",x,y+4.8-(charged*4.8),charged*4.8) or ""),
-	},"")
-end

machines/extractor.lua

@@ -15,55 +15,18 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.Extractor=table.copy(industrialtest.SimpleElectricItemProcessor)
+
-industrialtest.internal.unpackTableInto(industrialtest.Extractor,{
+industrialtest.internal.registerSimpleElectricItemProcessor({
-	name="industrialtest:extractor",
+	name="extractor",
-	description=S("Extractor"),
+	displayName=S("Extractor"),
-	tiles={
+	customFrontTexture=true,
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_extractor_front.png"
-	},
 	requiresWrench=true,
-	active={
+	capacity=900,
-		tiles={
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png^industrialtest_extractor_front_active.png"
-		}
-	},
-	capacity=1000,
 	flow=industrialtest.api.lvPowerFlow,
 	opPower=100,
+	method="industrialtest.extracting",
 	efficiency=1
 })
-
-function industrialtest.Extractor.getCraftResult(self,itemstack)
-	local output=industrialtest.api.getExtractorRecipeResult(itemstack:get_name())
-	if not output then
-		return {
-			item=ItemStack(),
-			time=0,
-			src=itemstack
-		}
-	end
-	local srcAfter=ItemStack(itemstack:get_name())
-	srcAfter:set_count(itemstack:get_count()-1)
-	return {
-		item=ItemStack(output.output),
-		time=output.time,
-		src=srcAfter
-	}
-end
-
-industrialtest.Extractor:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:extractor",

machines/fluid_generator.lua

@@ -15,75 +15,70 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
+local fluidGenerator={}
 
--- Common functions
+fluidGenerator.getFormspec=function(pos,config)
-local function onConstruct(pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	inv:set_size("charged",1)
-	inv:set_size("src",1)
-	inv:set_size("dst",1)
-	meta:set_float("fluidAmount",0)
-	meta:set_string("fluid","")
-end
-
-local function getFormspec(self,pos)
-	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	local fluidPercent=meta:get_float("fluidAmount")/100
 	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
 	local fluid=meta:get_string("fluid")
-	local fuel=self.getFuel(fluid)
+	local formspec
+	local fuel=config.getFuel(fluid)
 	local tile=(fuel and fuel.texture or "industrialtest_gui_fluid_bg.png")
-	local formspec={
+	if industrialtest.mtgAvailable then
-		"list[context;src;2,1.8;1,1]",
+		formspec={
-		industrialtest.internal.getItemSlotBg(2,1.8,1,1),
+			"list[context;fluid;2,1.8;1,1]",
+			"listring[context;fluid]",
 			(fluidPercent>0 and "image[2,3;1,1;industrialtest_gui_fluid_bg.png^[lowpart:"..fluidPercent..":"..tile.."]" or "image[2,3;1,1;industrialtest_gui_fluid_bg.png]"),
-		"list[context;dst;2,4.2;1,1]",
+			"list[context;leftover;2,4.2;1,1]",
-		industrialtest.internal.getItemSlotBg(2,4.2,1,1),
+			"listring[context;leftover]",
 			"list[context;charged;6,3;1,1]",
-		industrialtest.internal.getItemSlotBg(6,3,1,1),
+			"listring[context;charged]",
-		self.createPowerIndicatorWidget(powerPercent,9,1),
+			"box[9,1;0.3,4.8;#202020]",
-		"listring[context;src]",
+			(powerPercent>0 and "box[9,"..(1+4.8-(powerPercent*4.8))..";0.3,"..(powerPercent*4.8)..";#FF1010]" or "")
-		"listring[context;dst]"
 		}
-	return parentFormspec..table.concat(formspec,"")
+	elseif industrialtest.mclAvailable then
+		formspec={
+			"list[context;fluid;2,1.8;1,1]",
+			mcl_formspec.get_itemslot_bg(2,1.8,1,1),
+			"listring[context;fluid]",
+			(fluidPercent>0 and "image[2,3;1,1;industrialtest_gui_fluid_bg.png^[lowpart:"..fluidPercent..":"..tile.."]" or "image[2,3;1,1;industrialtest_gui_fluid_bg.png]"),
+			"list[context;leftover;2,4.2;1,1]",
+			mcl_formspec.get_itemslot_bg(2,4.2,1,1),
+			"listring[context;leftover]",
+			"list[context;charged;6,3;1,1]",
+			mcl_formspec.get_itemslot_bg(6,3,1,1),
+			"listring[context;charged]",
+			"box[9,1;0.3,4.8;#202020]",
+			(powerPercent>0 and "box[9,"..(1+4.8-(powerPercent*4.8))..";0.3,"..(powerPercent*4.8)..";#FF1010]" or "")
+		}
+	end
+	return table.concat(formspec,"")
 end
 
-local function allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count)
+fluidGenerator.onConstruct=function(pos,meta,inv)
-	if toList=="dst" then
+	inv:set_size("charged",1)
-		return 0
+	inv:set_size("fluid",1)
-	end
+	inv:set_size("leftover",1)
-	return count
+	meta:set_float("fluidAmount",0)
+	meta:set_string("fluid","")
 end
 
-local function allowMetadataInventoryPut(pos,listname,index,stack,player)
+fluidGenerator.onTimer=function(pos,elapsed,meta,inv,config)
-	if listname=="dst" then
+	local fluidSlot=inv:get_stack("fluid",1)
-		return 0
+	local chargedSlot=inv:get_stack("charged",1)
-	end
+	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
-	return stack:get_count()
+	local shouldUpdateFormspec=false
-end
+	local shouldRerunTimer=(afterFlow and meta:get_int("industrialtest.powerAmount")>0)
-
+	if fluidSlot:get_count()>0 and meta:get_float("fluidAmount")<=9000 then
-local function takeFuelFromItem(self,pos)
+		local fuel=config.getFuelByItem(fluidSlot:get_name())
-	local meta=minetest.get_meta(pos)
+		if fuel and (fuel.name==meta:get_string("fluid") or meta:get_string("fluid")=="") then
-	local inv=meta:get_inventory()
-	local fluidSlot=inv:get_stack("src",1)
-	local fluid=meta:get_string("fluid")
-	local fluidAmount=meta:get_float("fluidAmount")
-
-	if fluidSlot:is_empty() or fluidAmount>9000 then
-		return false
-	end
-
-	local fuel=self.getFuelByItem(fluidSlot:get_name())
-	if fuel and (fuel.name==fluid or fluid=="") then
 			local leftover=false
 			local leftoverAddingSucceeded=false
 			for _,item in ipairs(fuel.storageItems) do
 				if item.name==fluidSlot:get_name() and item.leftover then
-				local leftoverItemstack=ItemStack(item.leftover)
+					if inv:room_for_item("leftover",ItemStack(item.leftover)) then
-				if inv:room_for_item("dst",leftoverItemstack) then
+						inv:add_item("leftover",ItemStack(item.leftover))
-					inv:add_item("dst",leftoverItemstack)
 						leftoverAddingSucceeded=true
 					end
 					leftover=true
@@ -91,247 +86,195 @@ local function takeFuelFromItem(self,pos)
 			end
 			if not leftover or leftoverAddingSucceeded then
 				fluidSlot:take_item()
-			inv:set_stack("src",1,fluidSlot)
+				inv:set_stack("fluid",1,fluidSlot)
 				meta:set_string("fluid",fuel.name)
-			meta:set_float("fluidAmount",fluidAmount+1000)
+				meta:set_float("fluidAmount",meta:get_float("fluidAmount")+1000)
-			return true
+				shouldUpdateFormspec=true
+				shouldRerunTimer=false
 			end
 		end
-
-	return false
 	end
-
+	if meta:get_float("fluidAmount")>=50 and not industrialtest.api.isFullyCharged(meta) then
-local function generate(self,pos,elapsed)
+		meta:set_float("fluidAmount",meta:get_int("fluidAmount")-50*elapsed)
-	local meta=minetest.get_meta(pos)
+		local toAdd=math.ceil(config.getFuel(meta:get_string("fluid")).calorificValue*elapsed)
-	local fluidAmount=meta:get_float("fluidAmount")
-
-	if fluidAmount>0 and not industrialtest.api.isFullyCharged(meta) then
-		local fluidUsed=math.min(fluidAmount,50)
-		meta:set_float("fluidAmount",fluidAmount-fluidUsed*elapsed)
-		local toAdd=math.ceil(self.getFuel(meta:get_string("fluid")).calorificValue*elapsed*fluidUsed/50)
 		industrialtest.api.addPower(meta,toAdd)
-		return true
-	end
-
-	return false
-end
-
-industrialtest.GeothermalGenerator=table.copy(industrialtest.ActivatedElectricMachine)
-industrialtest.internal.unpackTableInto(industrialtest.GeothermalGenerator,{
-	name="industrialtest:geothermal_generator",
-	description=S("Geothermal Generator"),
-	tiles={
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_geothermal_generator_front.png"
-	},
-	sounds="metal",
-	facedir=true,
-	storageLists={
-		"src",
-		"dst",
-		"charged"
-	},
-	active={
-		tiles={
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png^industrialtest_geothermal_generator_front_active.png"
-		},
-		lightSource=10
-	},
-	powerLists={
-		{
-			list="charged",
-			direction="o"
-		}
-	},
-	requiresWrench=true,
-	hasPowerOutput=true,
-	capacity=7000,
-	flow=industrialtest.api.lvPowerFlow,
-	ioConfig="oooooo",
-	getFormspec=getFormspec,
-	getFuel=industrialtest.api.getGeothermalGeneratorFuel,
-	getFuelByItem=industrialtest.api.getGeothermalGeneratorFuelByItem
-})
-
-function industrialtest.GeothermalGenerator.onConstruct(self,pos)
-	onConstruct(pos)
-	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
-end
-
-function industrialtest.GeothermalGenerator.update(self,pos,elapsed,meta,inv)
-	local srcSlot=inv:get_stack("src",1)
-	local dstSlot=inv:get_stack("dst",1)
-	local shouldUpdateFormspec=takeFuelFromItem(self,pos)
-	return (not srcSlot:is_empty() and dstSlot:get_free_space()>0 and not industrialtest.api.isFluidStorageFull(meta)),shouldUpdateFormspec
-end
-
-function industrialtest.GeothermalGenerator.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	return math.min(allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count),industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count))
-end
-
-function industrialtest.GeothermalGenerator.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
-	return math.min(allowMetadataInventoryPut(pos,listname,index,stack,player),industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player))
-end
-
-function industrialtest.GeothermalGenerator.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	if toList=="src" and takeFuelFromItem(self,pos) then
-		self:trigger(pos)
-	end
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-end
-
-function industrialtest.GeothermalGenerator.onMetadataInventoryPut(self,pos,listname,index,stack)
-	if listname=="src" and takeFuelFromItem(self,pos) then
-		self:trigger(pos)
-	end
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
-end
-
-function industrialtest.GeothermalGenerator.shouldActivate(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local srcSlot=inv:get_stack("src",1)
-	local dstSlot=inv:get_stack("dst",1)
-	local fluidAmount=meta:get_float("fluidAmount")
-
-	return (fluidAmount>0 or (not srcSlot:is_empty() and dstSlot:get_free_space()>0)) and not industrialtest.api.isFullyCharged(meta)
-end
-
-function industrialtest.GeothermalGenerator.shouldDeactivate(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local srcSlot=inv:get_stack("src",1)
-	local dstSlot=inv:get_stack("dst",1)
-	local fluidAmount=meta:get_float("fluidAmount")
-
-	return (fluidAmount<=0 and (srcSlot:is_empty() or dstSlot:get_free_space()==0)) or industrialtest.api.isFullyCharged(meta)
-end
-
-function industrialtest.GeothermalGenerator.activeUpdate(self,pos,elapsed)
-	local shouldUpdateFormspec=false
-
-	if takeFuelFromItem(self,pos) then
 		shouldUpdateFormspec=true
-	end
+		if config.registerActiveVariant then
-
+			minetest.swap_node(pos,{
-	if generate(self,pos,elapsed) then
+				name="industrialtest:"..config.name.."_active",
-		shouldUpdateFormspec=true
+				param2=minetest.get_node(pos).param2
-	end
-
-	return shouldUpdateFormspec
-end
-
-industrialtest.GeothermalGenerator:register()
-
-minetest.register_craft({
-	type="shaped",
-	output="industrialtest:geothermal_generator",
-	recipe={
-		{industrialtest.elementKeys.glass,"industrialtest:empty_cell",industrialtest.elementKeys.glass},
-		{industrialtest.elementKeys.glass,"industrialtest:empty_cell",industrialtest.elementKeys.glass},
-		{"industrialtest:refined_iron_ingot","industrialtest:generator","industrialtest:refined_iron_ingot"}
-	}
 			})
-
+			minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-industrialtest.WaterMill=table.copy(industrialtest.ElectricMachine)
+		else
-industrialtest.internal.unpackTableInto(industrialtest.WaterMill,{
+			shouldRerunTimer=true
-	name="industrialtest:water_mill",
-	description=S("Water Mill"),
-	tiles={
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_water_mill_side.png",
-		"industrialtest_machine_block.png^industrialtest_water_mill_side.png",
-		"industrialtest_machine_block.png^industrialtest_water_mill_side.png",
-		"industrialtest_machine_block.png^industrialtest_water_mill_side.png"
-	},
-	sounds="metal",
-	storageLists={
-		"src",
-		"dst",
-		"charged"
-	},
-	powerLists={
-		{
-			list="charged",
-			direction="o"
-		}
-	},
-	requiresWrench=true,
-	hasPowerOutput=true,
-	capacity=7000,
-	flow=industrialtest.api.lvPowerFlow,
-	ioConfig="oooooo",
-	getFormspec=getFormspec,
-	getFuel=industrialtest.api.getWaterMillFuel,
-	getFuelByItem=industrialtest.api.getWaterMillFuelByItem
-})
-
-function industrialtest.WaterMill.onConstruct(self,pos)
-	onConstruct(pos)
-	industrialtest.ElectricMachine.onConstruct(self,pos)
 		end
-
-function industrialtest.WaterMill.canUpdate(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local srcSlot=inv:get_stack("src",1)
-	local dstSlot=inv:get_stack("dst",1)
-	local fluidAmount=meta:get_float("fluidAmount")
-
-	return (fluidAmount>0 or (not srcSlot:is_empty() and dstSlot:get_free_space()>0)) and not industrialtest.api.isFullyCharged(meta)
 	end
-
+	if chargedSlot:get_count()>0 and meta:get_int("industrialtest.powerAmount")>0 then
-function industrialtest.WaterMill.update(self,pos,elapsed)
+		if industrialtest.api.transferPowerToItem(meta,chargedSlot,industrialtest.api.lvPowerFlow)>0 then
-	local shouldUpdateFormspec=false
+			inv:set_stack("charged",1,chargedSlot)
-	local shouldRerunTimer=false
-
-	if takeFuelFromItem(self,pos) then
 			shouldUpdateFormspec=true
 			shouldRerunTimer=true
 		end
-
-	if generate(self,pos,elapsed) then
-		shouldUpdateFormspec=true
-		shouldRerunTimer=true
 	end
-
+	if flowTransferred then
+		shouldUpdateFormspec=true
+	end
 	return shouldRerunTimer,shouldUpdateFormspec
 end
 
-function industrialtest.WaterMill.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+fluidGenerator.metadataChange=function(pos)
-	return math.min(allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count),industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count))
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 end
 
-function industrialtest.WaterMill.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
+fluidGenerator.activeOnTimer=function(pos,elapsed,meta,inv,config)
-	return math.min(allowMetadataInventoryPut(pos,listname,index,stack,player),industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player))
+	local fluidSlot=inv:get_stack("fluid",1)
+	local chargedSlot=inv:get_stack("charged",1)
+	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
+	local shouldUpdateFormspec=false
+	local shouldRerunTimer=(afterFlow and meta:get_int("industrialtest.powerAmount")>0)
+
+	if fluidSlot:get_count()>0 and meta:get_float("fluidAmount")<=9000 then
+		local fuel=config.getFuelByItem(fluidSlot:get_name())
+		if fuel and (fuel.name==meta:get_string("fluid") or meta:get_string("fluid")=="") then
+			local leftover=false
+			local leftoverAddingSucceeded=false
+			for _,item in ipairs(fuel.storageItems) do
+				if item.name==fluidSlot:get_name() and item.leftover then
+					if inv:room_for_item("leftover",ItemStack(item.leftover)) then
+						inv:add_item("leftover",ItemStack(item.leftover))
+						leftoverAddingSucceeded=true
+					end
+					leftover=true
+				end
+			end
+			if not leftover or leftoverAddingSucceeded then
+				fluidSlot:take_item()
+				inv:set_stack("fluid",1,fluidSlot)
+				meta:set_string("fluid",fuel.name)
+				meta:set_float("fluidAmount",meta:get_float("fluidAmount")+1000)
+				shouldUpdateFormspec=true
+				shouldRerunTimer=false
+			end
+		end
+	end
+	if meta:get_float("fluidAmount")>=50 and not industrialtest.api.isFullyCharged(meta) then
+		meta:set_float("fluidAmount",meta:get_int("fluidAmount")-50*elapsed)
+		local toAdd=math.ceil(industrialtest.api.getGeothermalGeneratorFuel(meta:get_string("fluid")).calorificValue*elapsed)
+		industrialtest.api.addPower(meta,toAdd)
+		shouldUpdateFormspec=true
+		shouldRerunTimer=true
+	else
+		minetest.swap_node(pos,{
+			name="industrialtest:"..config.name,
+			param2=minetest.get_node(pos).param2
+		})
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	end
+	if chargedSlot:get_count()>0 and meta:get_int("industrialtest.powerAmount")>0 then
+		if industrialtest.api.transferPowerToItem(meta,chargedSlot,industrialtest.api.lvPowerFlow)>0 then
+			inv:set_stack("charged",1,chargedSlot)
+			shouldUpdateFormspec=true
+			shouldRerunTimer=true
+		end
+	end
+	if flowTransferred then
+		shouldUpdateFormspec=true
+	end
+	return shouldRerunTimer,shouldUpdateFormspec
 end
 
-function industrialtest.WaterMill.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+local function registerFluidGenerator(config)
-	if toList=="src" and takeFuelFromItem(self,pos) then
+	local definition={
-		self:trigger(pos)
+		name=config.name,
+		displayName=config.displayName,
+		getFormspec=function(pos)
+			return fluidGenerator.getFormspec(pos,config)
+		end,
+		capacity=7000,
+		flow=industrialtest.api.lvPowerFlow,
+		ioConfig="oooooo",
+		requiresWrench=true,
+		registerActiveVariant=config.registerActiveVariant,
+		powerSlots={"charged"},
+		storageSlots={"fluid","fluidLeftover"},
+		sounds="metal",
+		groups={
+			_industrialtest_hasPowerOutput=1
+		},
+		customKeys={
+			tiles={
+				"industrialtest_machine_block.png"..(config.customTopTexture and "^"..config.customTopTexture or ""),
+				"industrialtest_machine_block.png"..(config.customBottomTexture and "^"..config.customBottomTexture or ""),
+				"industrialtest_machine_block.png"..(config.customRightTexture and "^"..config.customRightTexture or ""),
+				"industrialtest_machine_block.png"..(config.customLeftTexture and "^"..config.customLeftTexture or ""),
+				"industrialtest_machine_block.png"..(config.customBackTexture and "^"..config.customBackTexture or ""),
+				"industrialtest_machine_block.png"..(config.customFrontTexture and "^"..config.customFrontTexture or "")
+			},
+			paramtype2="facedir",
+			legacy_facedir_simple=true
+		},
+		onConstruct=fluidGenerator.onConstruct,
+		onTimer=function(pos,elapsed,meta,inv)
+			return fluidGenerator.onTimer(pos,elapsed,meta,inv,config)
+		end,
+		onMetadataInventoryPut=fluidGenerator.metadataChange,			
+		onMetadataInventoryMove=fluidGenerator.metadataChange
+	}
+	if config.registerActiveVariant then
+		definition.activeCustomKeys={
+			tiles={
+				"industrialtest_machine_block.png"..(config.customTopTexture and "^"..config.customTopTextureActive or ""),
+				"industrialtest_machine_block.png"..(config.customBottomTexture and "^"..config.customBottomTextureActive or ""),
+				"industrialtest_machine_block.png"..(config.customRightTexture and "^"..config.customRightTextureActive or ""),
+				"industrialtest_machine_block.png"..(config.customLeftTexture and "^"..config.customLeftTextureActive or ""),
+				"industrialtest_machine_block.png"..(config.customBackTexture and "^"..config.customBackTextureActive or ""),
+				"industrialtest_machine_block.png"..(config.customFrontTexture and "^"..config.customFrontTextureActive or "")
+			},
+			light_source=8
+		}
+		definition.activeOnTimer=function(pos,elapsed,meta,inv)
+			return fluidGenerator.activeOnTimer(pos,elapsed,meta,inv,config)
 		end
-	industrialtest.ElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+	end
+	industrialtest.internal.registerMachine(definition)
 end
 
-function industrialtest.WaterMill.onMetadataInventoryPut(self,pos,listname,index,stack)
+registerFluidGenerator({
-	if listname=="src" and takeFuelFromItem(self,pos) then
+	name="geothermal_generator",
-		self:trigger(pos)
+	displayName=S("Geothermal Generator"),
-	end
+	customFrontTexture="industrialtest_geothermal_generator_front.png",
-	industrialtest.ElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
+	customFrontTextureActive="industrialtest_geothermal_generator_front_active.png",
-end
+	getFuel=industrialtest.api.getGeothermalGeneratorFuel,
+	getFuelByItem=industrialtest.api.getGeothermalGeneratorFuelByItem,
+	registerActiveVariant=true,
+	reactsToNeighbouringNodes=false
+})
 
-function industrialtest.WaterMill.action(self,pos)
+registerFluidGenerator({
+	name="water_mill",
+	displayName=S("Water Mill"),
+	customLeftTexture="industrialtest_water_mill_side.png",
+	customRightTexture="industrialtest_water_mill_side.png",
+	customFrontTexture="industrialtest_water_mill_side.png",
+	customBackTexture="industrialtest_water_mill_side.png",
+	getFuel=industrialtest.api.getWaterMillFuel,
+	getFuelByItem=industrialtest.api.getWaterMillFuelByItem,
+	registerActiveVariant=false
+})
+local neighbors={}
+for key,_ in pairs(industrialtest.api.waterMillFuels) do
+	table.insert(neighbors,key)
+end
+minetest.register_abm({
+	label="Water Mill generating",
+	nodenames={"industrialtest:water_mill"},
+	neighbors=neighbors,
+	interval=industrialtest.updateDelay,
+	chance=1,
+	action=function(pos,node)
 		local meta=minetest.get_meta(pos)
+		local inv=meta:get_inventory()
+		local chargedSlot=inv:get_stack("charged",1)
 		local powerToAdd=0
 		local neighbourPositions={
 			vector.offset(pos,-1,0,0),
@@ -351,25 +294,14 @@ function industrialtest.WaterMill.action(self,pos)
 			end
 		end
 		if industrialtest.api.addPower(meta,powerToAdd)>0 then
-		self:updateFormspec(pos)
+			local def=minetest.registered_nodes[node.name]
-		self:trigger(pos)
+			def._industrialtest_updateFormspec(meta)
+		end
+		if chargedSlot:get_count()>0 and meta:get_int("industrialtest.powerAmount")>0 then
+			if industrialtest.api.transferPowerToItem(meta,chargedSlot,industrialtest.api.lvPowerFlow)>0 then
+				inv:set_stack("charged",1,chargedSlot)
 			end
 		end
-
-industrialtest.WaterMill:register()
-
-local neighbors={}
-for key,_ in pairs(industrialtest.api.waterMillFuels) do
-	table.insert(neighbors,key)
-end
-minetest.register_abm({
-	label="Water Mill generating",
-	nodenames={"industrialtest:water_mill"},
-	neighbors=neighbors,
-	interval=industrialtest.config.updateDelay,
-	chance=1,
-	action=function(pos)
-		industrialtest.WaterMill:action(pos)
 	end
 })
 

machines/generator.lua

@@ -15,151 +15,169 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.Generator=table.copy(industrialtest.ActivatedElectricMachine)
+local generator={}
-industrialtest.internal.unpackTableInto(industrialtest.Generator,{
+
+generator.getFormspec=function(pos)
+	local meta=minetest.get_meta(pos)
+	local fuelPercent=meta:get_int("fuelTime")/meta:get_int("maxFuelTime")*100
+	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
+	local formspec
+	if industrialtest.mtgAvailable then
+		formspec={
+			"list[context;charged;4.9,1.8;1,1]",
+			"listring[context;charged]",
+			(fuelPercent>0 and "image[4.9,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
+			 or "image[4.9,2.8;1,1;default_furnace_fire_bg.png]"),
+			"list[context;fuel;4.9,3.9;1,1]",
+			"listring[context;fuel]",
+			"box[9,1;0.3,4.8;#202020]",
+			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or "")
+		}
+	elseif industrialtest.mclAvailable then
+		formspec={
+			"list[context;charged;4.7,1.8;1,1]",
+			mcl_formspec.get_itemslot_bg(4.7,1.8,1,1),
+			"listring[context;charged]",
+			(fuelPercent>0 and "image[4.7,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
+			 or "image[4.7,2.8;1,1;default_furnace_fire_bg.png]"),
+			"list[context;fuel;4.7,3.9;1,1]",
+			mcl_formspec.get_itemslot_bg(4.7,3.9,1,1),
+			"listring[context;fuel]",
+			"box[9,1;0.3,4.8;#202020]",
+			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or "")
+		}
+	end
+	return table.concat(formspec,"")
+end
+
+generator.onConstruct=function(pos,meta,inv)
+	inv:set_size("charged",1)
+	inv:set_size("fuel",1)
+	meta:set_int("fuelTime",0)
+	meta:set_int("maxFuelTime",1)
+end
+
+generator.onTimer=function(pos,elapsed,meta,inv)
+	local powerFlow=meta:get_int("industrialtest.powerFlow")
+	local chargedSlot=inv:get_stack("charged",1)
+	local fuelSlot=inv:get_stack("fuel",1)
+	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
+	local shouldUpdateFormspec=flowTransferred
+	local shouldRerunTimer=(afterFlow and meta:get_int("industrialtest.powerAmount")>0)
+	if chargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(chargedSlot:get_meta()) and meta:get_int("industrialtest.powerAmount")>0 then
+		industrialtest.api.transferPowerToItem(meta,chargedSlot,powerFlow)
+		inv:set_stack("charged",1,chargedSlot)
+		shouldUpdateFormspec=true
+		shouldRerunTimer=true
+	end
+	if fuelSlot:get_count()>0 and meta:get_int("fuelTime")<=0 and not industrialtest.api.isFullyCharged(meta) then
+		local output,after=minetest.get_craft_result({
+			method="fuel",
+			width=1,
+			items={fuelSlot}
+		})
+		if output.time>0 then
+			meta:set_int("fuelTime",output.time)
+			meta:set_int("maxFuelTime",output.time)
+			inv:set_stack("fuel",1,after.items[1])
+			minetest.swap_node(pos,{
+				name="industrialtest:generator_active",
+				param2=minetest.get_node(pos).param2
+			})
+			minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		end
+	end
+	return shouldRerunTimer,shouldUpdateFormspec
+end
+
+generator.activeOnTimer=function(pos,elapsed,meta,inv)
+	local chargedSlot=inv:get_stack("charged",1)
+	local fuelSlot=inv:get_stack("fuel",1)
+	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
+	local shouldUpdateFormspec=flowTransferred
+	local shouldRerunTimer=(afterFlow and meta:get_int("industrialtest.powerAmount")>0)
+	if chargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(chargedSlot:get_meta()) and meta:get_int("industrialtest.powerAmount")>0 then
+		industrialtest.api.transferPowerToItem(meta,chargedSlot,chargedSlot:get_meta():get_int("industrialtest.powerFlow"))
+		inv:set_stack("charged",1,chargedSlot)
+		shouldUpdateFormspec=true
+		shouldRerunTimer=true
+	end
+	if fuelSlot:get_count()>0 and meta:get_int("fuelTime")<=0 and not industrialtest.api.isFullyCharged(meta) then
+		local output,after=minetest.get_craft_result({
+			method="fuel",
+			width=1,
+			items={fuelSlot}
+		})
+		if output.time>0 then
+			meta:set_int("fuelTime",output.time)
+			meta:set_int("maxFuelTime",output.time)
+			inv:set_stack("fuel",1,after.items[1])
+		end
+	end
+	if meta:get_int("fuelTime")>0 then
+		meta:set_int("fuelTime",meta:get_int("fuelTime")-elapsed)
+		industrialtest.api.addPower(meta,200)
+		shouldUpdateFormspec=true
+		shouldRerunTimer=true
+	else
+		minetest.swap_node(pos,{
 			name="industrialtest:generator",
-	description=S("Generator"),
+			param2=minetest.get_node(pos).param2
-	tiles={
+		})
-		"industrialtest_machine_block.png",
+	end
-		"industrialtest_machine_block.png",
+	return shouldRerunTimer,shouldUpdateFormspec
-		"industrialtest_machine_block.png",
+end
-		"industrialtest_machine_block.png",
+
-		"industrialtest_machine_block.png",
+generator.metadataChange=function(pos)
-		"industrialtest_machine_block.png^industrialtest_iron_furnace_front.png"
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-	},
+end
-	sounds="metal",
+
-	facedir=true,
+industrialtest.internal.registerMachine({
-	storageLists={
+	name="generator",
-		"src",
+	displayName=S("Generator"),
-		"charged"
+	getFormspec=generator.getFormspec,
-	},
-	active={
-		tiles={
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png^industrialtest_iron_furnace_front_active.png"
-		},
-		lightSource=8
-	},
 	capacity=7000,
 	flow=industrialtest.api.lvPowerFlow,
 	ioConfig="oooooo",
-	hasPowerOutput=true,
+	registerActiveVariant=true,
-	powerLists={
+	powerSlots={"charged"},
-		{
+	storageSlots={"charged","fuel"},
-			list="charged",
+	sounds="metal",
-			direction="o"
+	groups={
-		}
+		_industrialtest_hasPowerOutput=1
-	}
+	},
+	customKeys={
+		tiles={
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png^industrialtest_iron_furnace_front.png",
+			"industrialtest_machine_block.png"
+		},
+		paramtype2="facedir",
+		legacy_facedir_simple=true
+	},
+	activeCustomKeys={
+		tiles={
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png^industrialtest_iron_furnace_front_active.png",
+			"industrialtest_machine_block.png"
+		},
+		light_source=8
+	},
+	onConstruct=generator.onConstruct,
+	onTimer=generator.onTimer,
+	activeOnTimer=generator.activeOnTimer,
+	onMetadataInventoryPut=generator.metadataChange,
+	onMetadataInventoryMove=generator.metadataChange
 })
 
-function industrialtest.Generator.onConstruct(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	inv:set_size("charged",1)
-	inv:set_size("src",1)
-	meta:set_float("fuelTime",0)
-	meta:set_float("maxFuelTime",1)
-	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
-end
-
-function industrialtest.Generator.getFormspec(self,pos)
-	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
-	local meta=minetest.get_meta(pos)
-	local fuelPercent=meta:get_float("fuelTime")/meta:get_float("maxFuelTime")*100
-	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
-	local formspec={
-		"list[context;charged;4.7,1.8;1,1]",
-		industrialtest.internal.getItemSlotBg(4.7,1.8,1,1),
-		(fuelPercent>0 and "image[4.7,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
-		 or "image[4.7,2.8;1,1;default_furnace_fire_bg.png]"),
-		"list[context;src;4.7,3.9;1,1]",
-		industrialtest.internal.getItemSlotBg(4.7,3.9,1,1),
-		self.createPowerIndicatorWidget(charged,9,1),
-		"listring[context;src]"
-	}
-	return parentFormspec..table.concat(formspec,"")
-end
-
-function industrialtest.Generator.onMetadataInventoryPut(self,pos,listname,index,stack)
-	self:triggerIfNeeded(pos)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
-end
-
-function industrialtest.Generator.activeUpdate(self,pos,elapsed,meta,inv)
-	local chargedSlot=inv:get_stack("charged",1)
-	local fuelSlot=inv:get_stack("src",1)
-	local shouldUpdateFormspec=false
-
-	if fuelSlot:get_count()>0 and meta:get_float("fuelTime")<=0 and not industrialtest.api.isFullyCharged(meta) then
-		local output,after=minetest.get_craft_result({
-			method="fuel",
-			width=1,
-			items={fuelSlot}
-		})
-		if output.time>0 then
-			meta:set_float("fuelTime",output.time)
-			meta:set_float("maxFuelTime",output.time)
-			inv:set_stack("src",1,after.items[1])
-		end
-	end
-
-	if meta:get_float("fuelTime")>0 then
-		meta:set_float("fuelTime",meta:get_float("fuelTime")-elapsed)
-		industrialtest.api.addPower(meta,200)
-		shouldUpdateFormspec=true
-	end
-
-	return shouldUpdateFormspec
-end
-
-function industrialtest.Generator.shouldActivate(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local fuelSlot=inv:get_stack("src",1)
-
-	if fuelSlot:get_count()>0 and not industrialtest.api.isFullyCharged(meta) then
-		local output,after=minetest.get_craft_result({
-			method="fuel",
-			width=1,
-			items={fuelSlot}
-		})
-		if output.time>0 then
-			return true
-		end
-	end
-
-	return false
-end
-
-function industrialtest.Generator.shouldDeactivate(self,pos)
-	local meta=minetest.get_meta(pos)
-
-	if meta:get_float("fuelTime")>0 then
-		return false
-	end
-
-	local inv=meta:get_inventory()
-	local fuelSlot=inv:get_stack("src",1)
-	if fuelSlot:get_count()>0 and not industrialtest.api.isFullyCharged(meta) then
-		local output,after=minetest.get_craft_result({
-			method="fuel",
-			width=1,
-			items={fuelSlot}
-		})
-		if output.time>0 then
-			return false
-		end
-	end
-
-	return true
-end
-
-industrialtest.Generator:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:generator",

machines/induction_furnace.lua

@@ -15,155 +15,98 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.InductionFurnace=table.copy(industrialtest.ActivatedElectricMachine)
-industrialtest.internal.unpackTableInto(industrialtest.InductionFurnace,{
-	name="industrialtest:induction_furnace",
-	description=S("Induction Furnace"),
-	tiles={
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png^industrialtest_electric_furnace_front.png"
-	},
-	sounds="metal",
-	requiresWrench=true,
-	facedir=true,
-	storageLists={
-		"src",
-		"dst",
-		"upgrades",
-		"powerStorage"
-	},
-	powerLists={
-		{
-			list="powerStorage",
-			direction="i"
-		}
-	},
-	active={
-		tiles={
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png^industrialtest_electric_furnace_front_active.png"
-		}
-	},
-	capacity=industrialtest.api.mvPowerFlow*2,
-	flow=industrialtest.api.mvPowerFlow,
-	hasPowerInput=true,
-	ioConfig="iiiiii",
-	_opPower=60,
-	_efficiency=0.5
-})
 
-function industrialtest.InductionFurnace.onConstruct(self,pos)
+local inductionFurnace={}
+inductionFurnace.opPower=60
+inductionFurnace.efficiency=0.5
+
+local function calculateMaxSrcTime(pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
+	local srcList=inv:get_list("src")
+
+	local maxSrcTime=0
+	for _,slot in ipairs(srcList) do
+		local result,_=minetest.get_craft_result({
+			method="cooking",
+			width=1,
+			items={slot}
+		})
+		maxSrcTime=math.max(maxSrcTime,result.time*inductionFurnace.efficiency)
+	end
+	meta:set_float("maxSrcTime",maxSrcTime)
+end
+
+inductionFurnace.getFormspec=function(pos)
+  local meta=minetest.get_meta(pos)
+	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
+	local maxSrcTime=meta:get_float("maxSrcTime")
+	local srcPercent=maxSrcTime>0 and meta:get_float("srcTime")/maxSrcTime*100 or 0
+	local heat=meta:get_int("heat")
+	local formspec
+	if industrialtest.mtgAvailable then
+    formspec={
+      "list[context;src;3.7,1.8;2,1]",
+			(powerPercent>0 and "image[3.7,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
+			 or "image[3.7,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
+			"list[context;powerStorage;3.7,3.9;1,1]",
+			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
+			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
+			"list[context;dst;6,2.8;2,1;]",
+			"list[context;upgrades;9,0.9;1,4]",
+			"label[0.5,2.8;"..minetest.formspec_escape(S("Heat: @1 %",heat)).."]",
+			"listring[context;src]",
+			"listring[context;powerStorage]",
+			"listring[context;dst]",
+			"listring[context;upgrades]"
+    }
+	elseif industrialtest.mclAvailable then
+    formspec={
+      "list[context;src;3.7,1.8;2,1]",
+      mcl_formspec.get_itemslot_bg(3.7,1.8,2,1),
+			(powerPercent>0 and "image[3.7,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
+			 or "image[3.7,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
+			"list[context;powerStorage;3.7,3.9;1,1]",
+			mcl_formspec.get_itemslot_bg(3.7,3.9,1,1),
+			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
+			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
+			"list[context;dst;6,2.8;2,1;]",
+			mcl_formspec.get_itemslot_bg(6,2.8,2,1),
+			"list[context;upgrades;9,0.9;1,4]",
+			mcl_formspec.get_itemslot_bg(9,0.9,1,4),
+			"label[0.5,2.8;"..minetest.formspec_escape(S("Heat: @1 %",heat)).."]",
+			"listring[context;src]",
+			"listring[context;powerStorage]",
+			"listring[context;dst]",
+			"listring[context;upgrades]"
+    }
+	end
+	return table.concat(formspec,"")
+end
+
+inductionFurnace.onConstruct=function(pos,meta,inv)
   inv:set_size("src",2)
   inv:set_size("dst",2)
   inv:set_size("powerStorage",1)
   inv:set_size("upgrades",4)
   meta:set_int("heat",0)
   meta:set_float("srcTime",0)
-	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
 end
 
-function industrialtest.InductionFurnace.getFormspec(self,pos)
+inductionFurnace.onTimer=function(pos,elapsed,meta,inv)
-	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
-	local meta=minetest.get_meta(pos)
-	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
-	local maxSrcTime=meta:get_float("maxSrcTime")
-	local srcPercent=maxSrcTime>0 and meta:get_float("srcTime")/maxSrcTime*100 or 0
-	local heat=meta:get_int("heat")
-	local formspec={
-		"list[context;src;3.7,1.8;2,1]",
-		industrialtest.internal.getItemSlotBg(3.7,1.8,2,1),
-		(powerPercent>0 and "image[3.7,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
-		 or "image[3.7,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
-		"list[context;powerStorage;3.7,3.9;1,1]",
-		industrialtest.internal.getItemSlotBg(3.7,3.9,1,1),
-		(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
-		 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
-		"list[context;dst;6,2.8;2,1;]",
-		industrialtest.internal.getItemSlotBg(6,2.8,2,1),
-		"list[context;upgrades;9,0.9;1,4]",
-		industrialtest.internal.getItemSlotBg(9,0.9,1,4),
-		"label[0.5,2.8;"..minetest.formspec_escape(S("Heat: @1 %",heat)).."]",
-		"listring[context;src]",
-		"listring[context;dst]"
-    }
-	return parentFormspec..table.concat(formspec,"")
-end
-
-function industrialtest.InductionFurnace.update(self,pos,elapsed,meta,inv)
-	local srcList=inv:get_list("src")
-	local heat=meta:get_int("heat")
   local shouldRerunTimer=false
   local shouldUpdateFormspec=false
+  local srcList=inv:get_list("src")
+  local heat=meta:get_int("heat")
+
+  shouldRerunTimer,shouldUpdateFormspec=industrialtest.internal.chargeFromPowerStorageItem(meta,inv)
 
   if heat>0 then
 		meta:set_int("heat",math.max(heat-math.max(2*elapsed,1),0))
-		shouldRerunTimer=true
+		shouldRerunTimer=shouldRerunTimer or heat>0
 		shouldUpdateFormspec=true
 	end
 
-	return shouldRerunTimer,shouldUpdateFormspec
-end
-
-function industrialtest.InductionFurnace.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	if toList=="dst" then
-		return 0
-	end
-	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-end
-
-function industrialtest.InductionFurnace.allowMetadataInventoryPut(self,pos,listname,index,stack)
-	if listname=="dst" then
-		return 0
-	end
-	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack)
-end
-
-function industrialtest.InductionFurnace.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	if fromList=="src" or toList=="src" then
-		self:calculateMaxSrcTime(pos)
-	end
-	if fromList=="src" and self.isInputEmpty(pos) then
-		local meta=minetest.get_meta(pos)
-		meta:set_float("srcTime",-1)
-		meta:set_float("maxSrcTime",0)
-		self:updateFormspec(pos)
-	elseif toList=="src" or (fromList=="dst" and not self.isOutputFull(pos)) then
-		self:triggerIfNeeded(pos)
-	end
-end
-
-function industrialtest.InductionFurnace.onMetadataInventoryPut(self,pos,listname,index,stack,player)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack,player)
-	if listname=="src" then
-		self:calculateMaxSrcTime(pos)
-		self:triggerIfNeeded(pos)
-	end
-end
-
-function industrialtest.InductionFurnace.onMetadataInventoryTake(self,pos,listname,index,stack)
-	if listname=="src" then
-		self:calculateMaxSrcTime(pos)
-	elseif listname=="dst" and not self.isOutputFull(pos) then
-		self:triggerIfNeeded(pos)
-	end
-end
-
-function industrialtest.InductionFurnace.shouldActivate(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local srcList=inv:get_list("src")
-
   for _,slot in ipairs(srcList) do
     if not slot:is_empty() then
       local result,after=minetest.get_craft_result({
@@ -172,27 +115,68 @@ function industrialtest.InductionFurnace.shouldActivate(self,pos)
         items={slot}
       })
       if result.time>0 and inv:room_for_item("dst",result.item) then
-				return meta:get_int("industrialtest.powerAmount")>=self._opPower
+        minetest.swap_node(pos,{
+          name="industrialtest:induction_furnace_active",
+          param2=minetest.get_node(pos).param2
+        })
+        minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+        return false,shouldUpdateFormspec
       end
     end
   end
 
-	return false
+	return shouldRerunTimer,shouldUpdateFormspec
 end
 
-function industrialtest.InductionFurnace.shouldDeactivate(self,pos)
+inductionFurnace.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
-	return not self:shouldActivate(pos)
+	if toList=="dst" then
+		return 0
+	end
+	return count
 end
 
-function industrialtest.InductionFurnace.activeUpdate(self,pos,elapsed,meta,inv)
+inductionFurnace.allowMetadataInventoryPut=function(pos,listname,index,stack)
+	if listname=="dst" then
+		return 0
+	end
+	return stack:get_count()
+end
+
+inductionFurnace.onMetadataInventoryPut=function(pos,listname)
+	if listname=="src" then
+		calculateMaxSrcTime(pos)
+	end
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+end
+
+inductionFurnace.onMetadataInventoryMove=function(pos,fromList,fromIndex,toList)
+	if fromList=="src" or toList=="src" then
+		calculateMaxSrcTime(pos)
+	end
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+end
+
+inductionFurnace.onMetadataInventoryTake=function(pos,listname)
+	if listname=="src" then
+		calculateMaxSrcTime(pos)
+	end
+	if listname=="dst" then
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	end
+end
+
+inductionFurnace.activeOnTimer=function(pos,elapsed,meta,inv)
 	local srcList=inv:get_list("src")
 	local powerAmount=meta:get_int("industrialtest.powerAmount")
 	local srcTime=meta:get_float("srcTime")
 	local maxSrcTime=meta:get_float("maxSrcTime")
 	local heat=meta:get_int("heat")
 	local speed=industrialtest.api.getMachineSpeed(meta)
-	local requiredPower=elapsed*self._opPower*speed
+	local requiredPower=elapsed*inductionFurnace.opPower*speed
 
+  industrialtest.internal.chargeFromPowerStorageItem(meta,inv)
+
+	local shouldContinue=false
 	local results={}
   for _,slot in ipairs(srcList) do
     if slot:is_empty() then
@@ -205,13 +189,23 @@ function industrialtest.InductionFurnace.activeUpdate(self,pos,elapsed,meta,inv)
       })
       if result.time>0 and inv:room_for_item("dst",result.item) then
 				table.insert(results,result.item)
+				shouldContinue=true
 			else
 				table.insert(results,false)
       end
     end
   end
+  if not shouldContinue or powerAmount<requiredPower then
+		meta:set_float("srcTime",0)
+		minetest.swap_node(pos,{
+			name="industrialtest:induction_furnace",
+			param2=minetest.get_node(pos).param2
+		})
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		return false,true
+  end
 
-	srcTime=srcTime+elapsed*(1+heat/200)
+	srcTime=srcTime+elapsed*(1+heat/100)
   if srcTime>=maxSrcTime then
 		for i,result in ipairs(results) do
 			if result then
@@ -233,56 +227,55 @@ function industrialtest.InductionFurnace.activeUpdate(self,pos,elapsed,meta,inv)
 
 	industrialtest.api.addPower(meta,-requiredPower)
 
-	return true
+  return true,true
 end
 
-function industrialtest.InductionFurnace.calculateMaxSrcTime(self,pos)
+industrialtest.internal.registerMachine({
-	local meta=minetest.get_meta(pos)
+  name="induction_furnace",
-	local inv=meta:get_inventory()
+  displayName=S("Induction Furnace"),
-	local srcList=inv:get_list("src")
+  capacity=industrialtest.api.mvPowerFlow*2,
-
+  getFormspec=inductionFurnace.getFormspec,
-	local maxSrcTime=0
+  flow=industrialtest.api.mvPowerFlow,
-	for _,slot in ipairs(srcList) do
+  ioConfig="iiiiii",
-		local result,_=minetest.get_craft_result({
+	requiresWrench=true,
-			method="cooking",
+	registerActiveVariant=true,
-			width=1,
+	sounds="metal",
-			items={slot}
+	powerSlots={"powerStorage"},
+	storageSlots={"src","dst","powerStorage","upgrades"},
+	groups={
+		_industrialtest_hasPowerInput=1
+	},
+	customKeys={
+		tiles={
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png^industrialtest_electric_furnace_front.png"
+		},
+		paramtype2="facedir",
+		legacy_facedir_simple=true
+	},
+	activeCustomKeys={
+		tiles={
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png^industrialtest_electric_furnace_front_active.png"
+		}
+	},
+  onConstruct=inductionFurnace.onConstruct,
+  onTimer=inductionFurnace.onTimer,
+  allowMetadataInventoryMove=inductionFurnace.allowMetadataInventoryMove,
+	allowMetadataInventoryPut=inductionFurnace.allowMetadataInventoryPut,
+	onMetadataInventoryPut=inductionFurnace.onMetadataInventoryPut,
+	onMetadataInventoryMove=inductionFurnace.onMetadataInventoryMove,
+	onMetadataInventoryTake=inductionFurnace.onMetadataInventoryTake,
+	activeOnTimer=inductionFurnace.activeOnTimer
 })
-		maxSrcTime=math.max(maxSrcTime,result.time*self._efficiency)
-	end
-	meta:set_float("maxSrcTime",maxSrcTime)
-end
-
-function industrialtest.InductionFurnace.isInputEmpty(pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local srcList=inv:get_list("src")
-
-	for _,slot in ipairs(srcList) do
-		if not slot:is_empty() then
-			return false
-		end
-	end
-
-	return true
-end
-
-function industrialtest.InductionFurnace.isOutputFull(pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local dstList=inv:get_list("dst")
-
-	for _,slot in ipairs(dstList) do
-		if slot:get_free_space()>0 then
-			return false
-		end
-	end
-
-	return true
-end
-
-industrialtest.InductionFurnace:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:induction_furnace",

machines/iron_furnace.lua

@@ -15,153 +15,115 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.IronFurnace=table.copy(industrialtest.ActivatedMachine)
+local ironFurnace={}
-industrialtest.internal.unpackTableInto(industrialtest.IronFurnace,{
-	name="industrialtest:iron_furnace",
-	description=S("Iron Furnace"),
-	tiles={
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_iron_furnace_front.png"
-	},
-	active={
-		tiles={
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png^industrialtest_iron_furnace_front_active.png"
-		},
-		lightSource=8
-	},
-	facedir=true,
-	storageLists={
-		"src",
-		"fuel",
-		"dst"
-	}
-})
 
-function industrialtest.IronFurnace.onConstruct(self,pos)
+ironFurnace.getFormspec=function(fuelPercent,srcPercent)
+	local formspec
+	if industrialtest.mtgAvailable then
+		formspec={
+			"formspec_version[4]",
+			"size[10.8,12]",
+			"label[0.5,0.5;"..S("Iron Furnace").."]",
+			"list[context;src;3.4,1.8;1,1]",
+			"listring[context;src]",
+			(fuelPercent>0 and "image[3.4,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
+			 or "image[3.4,2.8;1,1;default_furnace_fire_bg.png]"),
+			"list[context;fuel;3.4,3.9;1,1]",
+			"listring[context;fuel]",
+			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
+			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
+			"list[context;dst;6.4,2.8;1,1]",
+			"listring[context;dst]",
+			"list[current_player;main;0.5,6.25;8,1]",
+			"list[current_player;main;0.5,7.5;8,3;8]"
+		}
+	elseif industrialtest.mclAvailable then
+		formspec={
+			"size[10.04,12]",
+			"label[0.25,0.25;"..S("Iron Furnace").."]",
+			"list[context;src;3.4,1.8;1,1]",
+			mcl_formspec.get_itemslot_bg(3.4,1.8,1,1),
+			"listring[context;src]",
+			(fuelPercent>0 and "image[3.4,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
+			 or "image[3.4,2.8;1,1;default_furnace_fire_bg.png]"),
+			"list[context;fuel;3.4,3.9;1,1]",
+			mcl_formspec.get_itemslot_bg(3.4,3.9,1,1),
+			"listring[context;fuel]",
+			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
+			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
+			"list[context;dst;6.4,2.8;1,1]",
+			mcl_formspec.get_itemslot_bg(6.4,2.8,1,1),
+			"listring[context;dst]",
+			"list[current_player;main;0.5,7;9,3;9]",
+			mcl_formspec.get_itemslot_bg(0.5,7,9,3),
+			"list[current_player;main;0.5,10.24;9,1]",
+			mcl_formspec.get_itemslot_bg(0.5,10.24,9,1)
+		}
+	end
+	return table.concat(formspec,"")
+end
+
+ironFurnace.onConstruct=function(pos)
 	local meta=minetest.get_meta(pos)
 	local inv=meta:get_inventory()
 	inv:set_size("src",1)
 	inv:set_size("dst",1)
 	inv:set_size("fuel",1)
+	meta:set_string("formspec",ironFurnace.getFormspec(0,0))
 	meta:set_float("fuelTime",0)
 	meta:set_float("maxFuelTime",1)
-	meta:set_float("srcTime",0)
-	meta:set_float("maxSrcTime",0)
-	industrialtest.ActivatedMachine.onConstruct(self,pos)
-end
-
-function industrialtest.IronFurnace.getFormspec(self,pos)
-	local parentFormspec=industrialtest.ActivatedMachine.getFormspec(self,pos)
-	local meta=minetest.get_meta(pos)
-	local fuelPercent=meta:get_float("fuelTime")/meta:get_float("maxFuelTime")*100
-	local maxSrcTime=meta:get_float("maxSrcTime")
-	local srcPercent=meta:get_float("srcTime")/(maxSrcTime>0 and maxSrcTime or 0)*100
-	local formspec
-	if industrialtest.mtgAvailable then
-		formspec={
-			"list[context;src;3.4,1.8;1,1]",
-			(fuelPercent>0 and "image[3.4,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
-			 or "image[3.4,2.8;1,1;default_furnace_fire_bg.png]"),
-			"list[context;fuel;3.4,3.9;1,1]",
-			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
-			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
-			"list[context;dst;6.4,2.8;1,1]",
-			"listring[context;src]",
-			"listring[context;dst]"
-		}
-	elseif industrialtest.mclAvailable then
-		formspec={
-			"list[context;src;3.4,1.8;1,1]",
-			mcl_formspec.get_itemslot_bg(3.4,1.8,1,1),
-			(fuelPercent>0 and "image[3.4,2.8;1,1;default_furnace_fire_bg.png^[lowpart:"..fuelPercent..":default_furnace_fire_fg.png]"
-			 or "image[3.4,2.8;1,1;default_furnace_fire_bg.png]"),
-			"list[context;fuel;3.4,3.9;1,1]",
-			mcl_formspec.get_itemslot_bg(3.4,3.9,1,1),
-			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
-			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
-			"list[context;dst;6.4,2.8;1,1]",
-			mcl_formspec.get_itemslot_bg(6.4,2.8,1,1),
-			"listring[context;src]",
-			"listring[context;dst]"
-		}
-	end
-	return parentFormspec..table.concat(formspec,"")
-end
-
-function industrialtest.IronFurnace.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	if toList=="dst" then
-		return 0
-	end
-	return industrialtest.ActivatedMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-end
-
-function industrialtest.IronFurnace.allowMetadataInventoryPut(self,pos,listname,index,stack)
-	if listname=="dst" then
-		return 0
-	elseif listname=="src" then
-		local meta=minetest.get_meta(pos)
-		local inv=meta:get_inventory()
-		local srcSlot=inv:get_stack("src",1)
-		if srcSlot:get_name()~=stack:get_name() then
-			meta:set_float("srcTime",0)
-			meta:set_float("maxSrcTime",0)
-		end
-	end
-	return industrialtest.ActivatedMachine.allowMetadataInventoryPut(self,pos,listname,index,stack)
-end
-
-function industrialtest.IronFurnace.allowMetadataInventoryTake(self,pos,listname,index,stack)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local srcSlot=inv:get_stack("src",1)
-	local dstSlot=inv:get_stack("dst",1)
-	if listname=="src" and stack:get_count()==srcSlot:get_count() then
-		meta:set_float("srcTime",0)
-		meta:set_float("maxSrcTime",0)
-		if meta:get_float("maxFuelTime")>0 then
-			self:updateFormspec(pos)
-		end
-	elseif listname=="dst" and dstSlot:get_free_space()==0 then
-		self:triggerIfNeeded(pos)
-	end
-	return industrialtest.ActivatedMachine.allowMetadataInventoryTake(self,pos,listname,index,stack)
-end
-
-function industrialtest.IronFurnace.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local srcSlot=inv:get_stack("src",1)
-	local dstSlot=inv:get_stack("dst",1)
-	if fromList=="src" and count==srcSlot:get_count() then
 	meta:set_float("srcTime",-1)
 	meta:set_float("maxSrcTime",0)
-		if meta:get_float("maxFuelTime")>0 then
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-			self:updateFormspec(pos)
-		end
-	elseif fromList=="dst" and dstSlot:get_free_space()==0 then
-		self:triggerIfNeeded(pos)
-	end
-	industrialtest.ActivatedMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 end
 
-function industrialtest.IronFurnace.onMetadataInventoryPut(self,pos,listname,index,stack)
+ironFurnace.onTimer=function(pos,elapsed)
-	self:triggerIfNeeded(pos)
+	local meta=minetest.get_meta(pos)
-	industrialtest.ActivatedMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
+	local inv=meta:get_inventory()
-end
-
-function industrialtest.IronFurnace.activeUpdate(self,pos,elapsed,meta,inv)
 	local srcSlot=inv:get_stack("src",1)
 	local fuelSlot=inv:get_stack("fuel",1)
 	local shouldUpdateFormspec=false
+	local shouldRerunTimer=false
+
+	if fuelSlot:get_count()>0 and meta:get_float("fuelTime")<=0 then
+		local output,after=minetest.get_craft_result({
+			method="cooking",
+			width=1,
+			items={srcSlot}
+		})
+		if output.time>0 and inv:room_for_item("dst",output.item) then
+			output,after=minetest.get_craft_result({
+				method="fuel",
+				width=1,
+				items={fuelSlot}
+			})
+			if output.time>0 then
+				meta:set_float("fuelTime",output.time)
+				meta:set_float("maxFuelTime",output.time)
+				inv:set_stack("fuel",1,after.items[1])
+				minetest.swap_node(pos,{
+					name="industrialtest:iron_furnace_active",
+					param2=minetest.get_node(pos).param2
+				})
+				minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+			end
+		end
+	end
+
+	if shouldUpdateFormspec then
+		meta:set_string("formspec",ironFurnace.getFormspec(meta:get_float("fuelTime")/meta:get_float("maxFuelTime")*100,meta:get_float("srcTime")/meta:get_float("maxSrcTime")*100))
+	end
+
+	return shouldRerunTimer
+end
+
+ironFurnace.activeOnTimer=function(pos,elapsed)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local srcSlot=inv:get_stack("src",1)
+	local fuelSlot=inv:get_stack("fuel",1)
+	local shouldUpdateFormspec=false
+	local shouldRerunTimer=false
 
 	if fuelSlot:get_count()>0 and meta:get_float("fuelTime")<=0 then
 		local output,after=minetest.get_craft_result({
@@ -194,11 +156,29 @@ function industrialtest.IronFurnace.activeUpdate(self,pos,elapsed,meta,inv)
 		end
 	end
 	if meta:get_float("fuelTime")>0 then
-		if meta:get_float("maxSrcTime")>0 then
-			meta:set_float("srcTime",meta:get_float("srcTime")+elapsed)
-		end
 		meta:set_float("fuelTime",meta:get_float("fuelTime")-elapsed)
 		shouldUpdateFormspec=true
+		shouldRerunTimer=true
+	end
+	if meta:get_float("maxSrcTime")>0 then
+		if meta:get_float("fuelTime")>0 then
+			meta:set_float("srcTime",meta:get_float("srcTime")+elapsed)
+		else
+			meta:set_float("srcTime",0)
+			minetest.swap_node(pos,{
+				name="industrialtest:iron_furnace",
+				param2=minetest.get_node(pos).param2
+			})
+			minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		end
+		shouldUpdateFormspec=true
+		shouldRerunTimer=true
+	elseif meta:get_float("fuelTime")<=0 then
+		minetest.swap_node(pos,{
+			name="industrialtest:iron_furnace",
+			param2=minetest.get_node(pos).param2
+		})
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
 	if meta:get_float("srcTime")>=meta:get_float("maxSrcTime") then
 		local output,after=minetest.get_craft_result({
@@ -214,77 +194,133 @@ function industrialtest.IronFurnace.activeUpdate(self,pos,elapsed,meta,inv)
 		end
 	end
 
-	return shouldUpdateFormspec
+	if shouldUpdateFormspec then
+		meta:set_string("formspec",ironFurnace.getFormspec(meta:get_float("fuelTime")/meta:get_float("maxFuelTime")*100,meta:get_float("srcTime")/meta:get_float("maxSrcTime")*100))
 	end
 
-function industrialtest.IronFurnace.shouldActivate(self,pos)
+	return shouldRerunTimer
+end
+
+ironFurnace.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
+	if toList=="dst" then
+		return 0
+	end
+	return count
+end
+
+ironFurnace.allowMetadataInventoryPut=function(pos,listname,index,stack)
+	if listname=="dst" then
+		return 0
+	elseif listname=="src" then
 		local meta=minetest.get_meta(pos)
 		local inv=meta:get_inventory()
-	local fuelSlot=inv:get_stack("fuel",1)
-	if fuelSlot:get_count()>0 then
 		local srcSlot=inv:get_stack("src",1)
-		local output,after=minetest.get_craft_result({
+		if srcSlot:get_name()~=stack:get_name() then
-			method="cooking",
+			meta:set_float("srcTime",-1)
-			width=1,
+			meta:set_float("maxSrcTime",0)
-			items={srcSlot}
-		})
-		if output.time>0 and inv:room_for_item("dst",output.item) then
-			output,after=minetest.get_craft_result({
-				method="fuel",
-				width=1,
-				items={fuelSlot}
-			})
-			if output.time>0 then
-				meta:set_float("fuelTime",output.time)
-				meta:set_float("maxFuelTime",output.time)
-				inv:set_stack("fuel",1,after.items[1])
-				return true
 		end
 	end
-	end
+	return stack:get_count()
-	return false
 end
 
-function industrialtest.IronFurnace.shouldDeactivate(self,pos)
+ironFurnace.onMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
 	local meta=minetest.get_meta(pos)
-
-	if meta:get_float("fuelTime")>0 then
-		return false
-	end
-
 	local inv=meta:get_inventory()
-
 	local srcSlot=inv:get_stack("src",1)
-	local srcOutput,_=minetest.get_craft_result({
+	local dstSlot=inv:get_stack("dst",1)
-		method="cooking",
+	if fromList=="src" and count==srcSlot:get_count() then
-		width=1,
+		meta:set_float("srcTime",-1)
-		items={srcSlot}
+		meta:set_float("maxSrcTime",0)
-	})
+		if meta:get_float("maxFuelTime")>0 then
-	if srcOutput.time==0 or not inv:room_for_item("dst",srcOutput.item) then
+			meta:set_string("formspec",ironFurnaceFormspec(meta:get_float("fuelTime")/meta:get_float("maxFuelTime")*100,0))
-		meta:set_float("srcTime",0)
+		end
-		return true
+	elseif fromList=="dst" and dstSlot:get_free_space()==0 then
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	end
 end
 
-	local fuelSlot=inv:get_stack("fuel",1)
+ironFurnace.onMetadataInventoryPut=function(pos,listname,index,stack)
-	local fuelOutput,_=minetest.get_craft_result({
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-		method="fuel",
-		width=1,
-		items={fuelSlot}
-	})
-	if fuelOutput.time==0 then
-		meta:set_float("srcTime",0)
-		return true
 end
 
-	return false
+ironFurnace.onMetadataInventoryTake=function(pos,listname,index,stack)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local srcSlot=inv:get_stack("src",1)
+	local dstSlot=inv:get_stack("dst",1)
+	if listname=="src" and stack:get_count()==srcSlot:get_count() then
+		meta:set_float("srcTime",-1)
+		meta:set_float("maxSrcTime",0)
+		if meta:get_float("maxFuelTime")>0 then
+			meta:set_string("formspec",ironFurnace.getFormspec(meta:get_float("fuelTime")/meta:get_float("maxFuelTime")*100,0))
+		end
+	elseif listname=="dst" and dstSlot:get_free_space()==0 then
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	end
 end
 
-function industrialtest.IronFurnace.afterDeactivation(self,pos)
+local definition={
-	self:updateFormspec(pos)
+	description=S("Iron Furnace"),
+	tiles={
+		"industrialtest_machine_block.png",
+		"industrialtest_machine_block.png",
+		"industrialtest_machine_block.png",
+		"industrialtest_machine_block.png",
+		"industrialtest_machine_block.png",
+		"industrialtest_machine_block.png^industrialtest_iron_furnace_front.png",
+		"industrialtest_machine_block.png"
+	},
+	paramtype2="facedir",
+	legacy_facedir_simple=true,
+	on_construct=ironFurnace.onConstruct,
+	on_timer=ironFurnace.onTimer,
+	allow_metadata_inventory_move=ironFurnace.allowMetadataInventoryMove,
+	allow_metadata_inventory_put=ironFurnace.allowMetadataInventoryPut,
+	on_metadata_inventory_move=ironFurnace.onMetadataInventoryMove,
+	on_metadata_inventory_put=ironFurnace.onMetadataInventoryPut,
+	on_metadata_inventory_take=ironFurnace.onMetadataInventoryTake
+}
+if industrialtest.mtgAvailable then
+	definition.groups={
+		cracky=1,
+		level=2
+	}
+	definition.sounds=default.node_sound_metal_defaults()
+	definition.can_dig=function(pos)
+		local meta=minetest.get_meta(pos)
+		local inv=meta:get_inventory()
+		return not (inv:get_list("src")[1]:get_count()>0 or inv:get_list("fuel")[1]:get_count()>0 or inv:get_list("dst")[1]:get_count()>0)
 	end
-
+elseif industrialtest.mclAvailable then
-industrialtest.IronFurnace:register()
+	definition.after_dig_node=function(pos,oldnode,oldmeta)
-
+		industrialtest.internal.mclAfterDigNode(pos,oldmeta,{"src","fuel","dst"})
+	end
+	definition.sounds=mcl_sounds.node_sound_metal_defaults()
+	definition._mcl_blast_resistance=3
+	definition._mcl_hardness=3.5
+end
+minetest.register_node("industrialtest:iron_furnace",definition)
+definition=table.copy(definition)
+definition.description=nil
+definition.tiles={
+	"industrialtest_machine_block.png",
+	"industrialtest_machine_block.png",
+	"industrialtest_machine_block.png",
+	"industrialtest_machine_block.png",
+	"industrialtest_machine_block.png",
+	"industrialtest_machine_block.png^industrialtest_iron_furnace_front_active.png",
+	"industrialtest_machine_block.png"
+}
+definition.light_source=8
+definition.drop="industrialtest:iron_furnace"
+definition.on_timer=ironFurnace.activeOnTimer
+if industrialtest.mclAvailable then
+	definition.groups={
+		not_in_creative_inventory=1
+	}
+	definition._doc_items_create_entry=false
+end
+minetest.register_node("industrialtest:iron_furnace_active",definition)
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:iron_furnace",

machines/macerator.lua

@@ -15,55 +15,18 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.Macerator=table.copy(industrialtest.SimpleElectricItemProcessor)
+
-industrialtest.internal.unpackTableInto(industrialtest.Macerator,{
+industrialtest.internal.registerSimpleElectricItemProcessor({
-	name="industrialtest:macerator",
+	name="macerator",
-	description=S("Macerator"),
+	displayName=S("Macerator"),
-	tiles={
+	customFrontTexture=true,
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_macerator_front.png"
-	},
 	requiresWrench=true,
-	active={
-		tiles={
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png^industrialtest_macerator_front_active.png"
-		}
-	},
 	capacity=1200,
 	flow=industrialtest.api.lvPowerFlow,
 	opPower=100,
+	method="industrialtest.macerating",
 	efficiency=1
 })
-
-function industrialtest.Macerator.getCraftResult(self,itemstack)
-	local output=industrialtest.api.getMaceratorRecipeResult(itemstack:get_name())
-	if not output then
-		return {
-			item=ItemStack(),
-			time=0,
-			src=itemstack
-		}
-	end
-	local srcAfter=ItemStack(itemstack:get_name())
-	srcAfter:set_count(itemstack:get_count()-1)
-	return {
-		item=ItemStack(output.output),
-		time=output.time,
-		src=srcAfter
-	}
-end
-
-industrialtest.Macerator:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:macerator",

machines/machine.lua

@@ -1,329 +0,0 @@
--- IndustrialTest
--- Copyright (C) 2024 mrkubax10
-
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
-
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
-
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-industrialtest.Machine={}
-
-function industrialtest.Machine.onConstruct(self,pos)
-	local meta=minetest.get_meta(pos)
-	if not self.withoutFormspec then
-		meta:set_string("formspec",self:getFormspec(pos))
-	end
-	self:trigger(pos)
-end
-
-function industrialtest.Machine.onDestruct(self)
-	-- dummy function
-end
-
-function industrialtest.Machine.afterPlaceNode(self,pos,placer,itemstack,pointed)
-	-- dummy function
-end
-
-function industrialtest.Machine.afterDigNode(self,pos,oldnode,oldmetadata,digger)
-	-- dummy function
-end
-
-function industrialtest.Machine.onDig(self,pos,node,digger)
-	-- dummy function
-	return minetest.node_dig(pos,node,digger)
-end
-
-function industrialtest.Machine.getFormspec(self,pos)
-	local formspec
-	if industrialtest.mtgAvailable then
-		formspec={
-			"formspec_version[4]",
-			"size[10.8,12]",
-			"label[0.5,0.5;"..self.description.."]",
-			"list[current_player;main;0.5,6.25;8,1]",
-			"list[current_player;main;0.5,7.5;8,3;8]",
-			"listring[current_player;main]"
-		}
-	elseif industrialtest.mclAvailable then
-		formspec={
-			"size[10.04,12]",
-			"label[0.25,0.25;"..self.description.."]",
-			"list[current_player;main;0.5,7;9,3;9]",
-			mcl_formspec.get_itemslot_bg(0.5,7,9,3),
-			"list[current_player;main;0.5,10.24;9,1]",
-			mcl_formspec.get_itemslot_bg(0.5,10.24,9,1),
-			"listring[current_player;main]"
-		}
-	end
-	return table.concat(formspec,"")
-end
-
-function industrialtest.Machine.updateFormspec(self,pos)
-	if self.withoutFormspec then
-		return
-	end
-
-	local meta=minetest.get_meta(pos)
-	meta:set_string("formspec",self:getFormspec(pos))
-end
-
-function industrialtest.Machine.canUpdate(self,pos)
-	return false
-end
-
-function industrialtest.Machine.trigger(self,pos)
-	local timer=minetest.get_node_timer(pos)
-	if not timer:is_started() then
-		timer:start(industrialtest.config.updateDelay)
-	end
-end
-
-function industrialtest.Machine.triggerIfNeeded(self,pos)
-	if self:canUpdate(pos) then
-		self:trigger(pos)
-	end
-end
-
-function industrialtest.Machine.onTimer(self,pos,elapsed)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local shouldRerunTimer=false
-	local shouldUpdateFormspec=false
-
-	if self.update then
-		shouldRerunTimer,shouldUpdateFormspec=self:update(pos,elapsed,meta,inv)
-	end
-
-	if shouldUpdateFormspec then
-		self:updateFormspec(pos)
-	end
-
-	return shouldRerunTimer
-end
-
-function industrialtest.Machine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local movedItemStack=inv:get_stack(fromList,1)
-
-	if toList=="upgrades" then
-		return self.allowMoveToUpgradeSlot(pos,toIndex,movedItemStack)
-	end
-
-	return count
-end
-
-function industrialtest.Machine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
-	if listname=="upgrades" then
-		return self.allowMoveToUpgradeSlot(pos,index,stack)
-	end
-
-	return stack:get_count()
-end
-
-function industrialtest.Machine.allowMetadataInventoryTake(self,pos,listname,index,stack,player)
-	return stack:get_count()
-end
-
-function industrialtest.Machine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	if toList=="upgrades" then
-		local meta=minetest.get_meta(pos)
-		local inv=meta:get_inventory()
-		local itemstack=inv:get_stack(fromList,fromIndex)
-		local def=itemstack:get_definition()
-		if def and def._industrialtest_self and def._industrialtest_self.apply then
-			def._industrialtest_self:apply(pos)
-		end
-	elseif fromList=="upgrades" then
-		local meta=minetest.get_meta(pos)
-		local inv=meta:get_inventory()
-		local itemstack=inv:get_stack(fromList,fromIndex)
-		local def=itemstack:get_definition()
-		if def and def._industrialtest_self and def._industrialtest_self.remove then
-			def._industrialtest_self:remove(pos)
-		end
-	end
-end
-
-function industrialtest.Machine.onMetadataInventoryPut(self,pos,listname,index,stack)
-	if listname=="upgrades" then
-		local def=stack:get_definition()
-		if def and def._industrialtest_self and def._industrialtest_self.apply then
-			def._industrialtest_self:apply(pos)
-		end
-	end
-end
-
-function industrialtest.Machine.onMetadataInventoryTake(self,pos,listname,index,stack)
-	if listname=="upgrades" then
-		local def=stack:get_definition()
-		if def and def._industrialtest_self and def._industrialtest_self.remove then
-			def._industrialtest_self:remove(pos)
-		end
-	end
-end
-
-function industrialtest.Machine.onReceiveFields(self,pos,formname,fields)
-	-- dummy function
-end
-
-local function mclAfterDigNode(pos,oldmeta,lists)
-	-- Taken from https://git.minetest.land/MineClone2/MineClone2/src/branch/master/mods/ITEMS/mcl_furnaces/init.lua#L538
-	local meta=minetest.get_meta(pos)
-	local meta2=meta
-	meta:from_table(oldmeta)
-	local inv=meta:get_inventory()
-	for _,listname in ipairs(lists) do
-		local stack=inv:get_stack(listname,1)
-		if not stack:is_empty() then
-			local p = {x=pos.x+math.random(0, 10)/10-0.5, y=pos.y, z=pos.z+math.random(0, 10)/10-0.5}
-			minetest.add_item(p, stack)
-		end
-	end
-	meta:from_table(meta2:to_table())
-end
-
-function industrialtest.Machine.createDefinitionTable(self)
-	local def={
-		description=self.description,
-		tiles=self.tiles,
-		on_construct=function(pos)
-			self:onConstruct(pos)
-		end,
-		on_destruct=function(pos)
-			self:onDestruct(pos)
-		end,
-		after_place_node=function(pos,placer,itemstack,pointed)
-			self:afterPlaceNode(pos,placer,itemstack,pointed)
-		end,
-		after_dig_node=function(pos,oldnode,oldmetadata,digger)
-			self:afterDigNode(pos,oldnode,oldmetadata,digger)
-		end,
-		on_dig=function(pos,node,digger)
-			return self:onDig(pos,node,digger)
-		end,
-		on_timer=function(pos,elapsed)
-			return self:onTimer(pos,elapsed)
-		end,
-		allow_metadata_inventory_move=function(pos,fromList,fromIndex,toList,toIndex,count)
-			return self:allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count)
-		end,
-		allow_metadata_inventory_put=function(pos,listname,index,stack,player)
-			return self:allowMetadataInventoryPut(pos,listname,index,stack,player)
-		end,
-		allow_metadata_inventory_take=function(pos,listname,index,stack,player)
-			return self:allowMetadataInventoryTake(pos,listname,index,stack,player)
-		end,
-		on_metadata_inventory_put=function(pos,listname,index,stack,player)
-			self:onMetadataInventoryPut(pos,listname,index,stack)
-		end,
-		on_metadata_inventory_move=function(pos,fromList,fromIndex,toList,toIndex,count)
-			self:onMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex)
-		end,
-		on_metadata_inventory_take=function(pos,listname,index,stack,player)
-			self:onMetadataInventoryTake(pos,listname,index,stack)
-		end,
-		on_receive_fields=function(pos,formname,fields)
-			self:onReceiveFields(pos,formname,fields)
-		end,
-		_industrialtest_self=self
-	}
-
-	if industrialtest.mtgAvailable then
-		def.groups={cracky=2}
-		if self.sounds=="metal" then
-			def.sounds=default.node_sound_metal_defaults()
-		elseif self.sounds=="wood" then
-			def.sounds=default.node_sound_wood_defaults()
-		end
-		def.can_dig=function(pos)
-			local meta=minetest.get_meta(pos)
-			local inv=meta:get_inventory()
-			for _,value in ipairs(self.storageLists) do
-				if inv:get_stack(value,1):get_count()>0 then
-					return false
-				end
-			end
-			return true
-		end
-	elseif industrialtest.mclAvailable then
-		def.after_dig_node=function(pos,oldnode,oldmeta)
-			mclAfterDigNode(pos,oldmeta,self.storageLists)
-		end
-		if self.sounds=="metal" then
-			def.sounds=mcl_sounds.node_sound_metal_defaults()
-		elseif sounds=="wood" then
-			def.sounds=mcl_sounds.node_sound_wood_defaults()
-		end
-		def.groups={
-			pickaxey=1,
-			container=2
-		}
-		def._mcl_blast_resistance=3.5
-		def._mcl_hardness=3.9
-		def._mcl_hoppers_on_try_pull=function(pos, hop_pos, hop_inv, hop_list)
-			local meta = minetest.get_meta(pos)
-			local inv = meta:get_inventory()
-			local stack = inv:get_stack("dst", 1)
-			if not stack:is_empty() and hop_inv:room_for_item(hop_list, stack) then
-				return inv, "dst", 1
-			end
-			return nil, nil, nil
-		end
-		def._mcl_hoppers_on_try_push=function(pos, hop_pos, hop_inv, hop_list)
-			local meta = minetest.get_meta(pos)
-			local inv = meta:get_inventory()
-			return inv, "src", mcl_util.select_stack(hop_inv, hop_list, inv, "src")
-		end
-		def._mcl_hoppers_on_after_push=function(pos)
-			self:triggerIfNeeded(pos)
-		end
-	end
-
-	def.groups._industrialtest_wrenchUnmountable=1
-	if self.requiresWrench then
-		def.drop="industrialtest:machine_block"
-	end
-
-	if self.facedir then
-		def.paramtype2="facedir"
-		def.legacy_facedir_simple=true
-	end
-
-	if self.hasPowerInput then
-		def.groups._industrialtest_hasPowerInput=1
-	end
-	if self.hasPowerOutput then
-		def.groups._industrialtest_hasPowerOutput=1
-	end
-
-	return def
-end
-
-function industrialtest.Machine.register(self)
-	local def=self:createDefinitionTable()
-	minetest.register_node(self.name,def)
-	industrialtest.api.addTag(self.name,"usesTimer")
-end
-
-function industrialtest.Machine.allowMoveToUpgradeSlot(pos,toIndex,itemstack)
-	local def=itemstack:get_definition()
-	if not def or not def.groups or not def.groups._industrialtest_machineUpgrade then
-		return 0
-	end
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local targetSlot=inv:get_stack("upgrades",toIndex)
-	if not targetSlot:is_empty() then
-		return 0
-	end
-	return itemstack:get_count()
-end

machines/mass_fabricator.lua

@@ -15,54 +15,20 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.MassFabricator=table.copy(industrialtest.SimpleElectricItemProcessor)
+local massFabricator={}
-industrialtest.internal.unpackTableInto(industrialtest.MassFabricator,{
+
-	name="industrialtest:mass_fabricator",
+industrialtest.internal.registerSimpleElectricItemProcessor({
-	description=S("Mass Fabricator"),
+	name="mass_fabricator",
-	tiles={
+	displayName=S("Mass Fabricator"),
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png^industrialtest_mass_fabricator_front.png"
-	},
-	requiresWrench=true,
-	active={
-		tiles={
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png^industrialtest_mass_fabricator_front_active.png"
-		}
-	},
 	capacity=100000,
+	requiresWrench=true,
 	flow=industrialtest.api.evPowerFlow,
 	opPower=10000,
+	machineBlockTexture="industrialtest_advanced_machine_block.png",
+	customFrontTexture=true,
+	method="industrialtest.mass_fabricating",
 	efficiency=1
 })
-
-function industrialtest.MassFabricator.getCraftResult(self,itemstack)
-	if itemstack:get_count()<34 or itemstack:get_name()~="industrialtest:scrap" then
-		return {
-			item=ItemStack(),
-			time=0,
-			src=itemstack
-		}
-	end
-	local srcAfter=ItemStack(itemstack:get_name())
-	srcAfter:set_count(itemstack:get_count()-34)
-	return {
-		item=ItemStack("industrialtest:uu_matter"),
-		time=15,
-		src=srcAfter
-	}
-end
-
-industrialtest.MassFabricator:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:mass_fabricator",

machines/miner.lua

@@ -1,388 +0,0 @@
--- IndustrialTest
--- Copyright (C) 2025 mrkubax10
-
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
-
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
-
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-local S=minetest.get_translator("industrialtest")
-
-local function destructMiningPipe(pos,player)
-	local count=0
-	local originalPos=table.copy(pos)
-	local node=minetest.get_node(pos)
-	while node.name=="industrialtest:mining_pipe" do
-		count=count+1
-		pos.y=pos.y-1
-		node=minetest.get_node(pos)
-		if node.name=="ignore" then
-			minetest.load_area(pos)
-			node=minetest.get_node(pos)
-		end
-	end
-	local endPos=table.copy(pos)
-
-	local manip=minetest.get_voxel_manip()
-	local minp,maxp=manip:read_from_map(pos,originalPos)
-	local data=manip:get_data()
-	local area=VoxelArea(minp,maxp)
-	pos=table.copy(originalPos)
-	while pos.y>endPos.y do
-		data[area:index(pos.x,pos.y,pos.z)]=minetest.CONTENT_AIR
-		pos.y=pos.y-1
-	end
-	manip:set_data(data)
-	manip:write_to_map()
-
-	if player then
-		local itemstack=ItemStack("industrialtest:mining_pipe "..tostring(count))
-		if industrialtest.mtgAvailable then
-			local inv=player:get_inventory()
-			local leftover=inv:add_item("main",itemstack)
-			if not leftover:is_empty() then
-				minetest.add_item(player:get_pos(),leftover)
-			end
-		elseif industrialtest.mclAvailable then
-			minetest.add_item(originalPos,itemstack)
-		end
-	end
-end
-
-local function miningPipeUpdateMiner(pos)
-	local meta=minetest.get_meta(pos)
-	if meta:contains("miner") then
-		local minerPos=minetest.deserialize(meta:get_string("miner"))
-		local minerMeta=minetest.get_meta(minerPos)
-		minerMeta:set_int("level",pos.y)
-	end
-end
-
-local definition={
-	description=S("Mining Pipe"),
-	tiles={"industrialtest_mining_pipe.png"},
-	paramtype="light",
-	sunlight_propagates=true,
-	drawtype="nodebox",
-	node_box={
-		type="fixed",
-		fixed={
-			-0.25,
-			-0.5,
-			-0.25,
-			0.25,
-			0.5,
-			0.25
-		}
-	},
-	on_destruct=function(pos)
-		miningPipeUpdateMiner(pos)
-		destructMiningPipe(pos,nil)
-	end,
-	on_dig=function(pos,node,digger)
-		miningPipeUpdateMiner(pos)
-		destructMiningPipe(pos,digger)
-	end
-}
-if industrialtest.mtgAvailable then
-	definition.groups={
-		cracky=3,
-		oddly_breakable_by_hand=1
-	}
-	definition.sounds=default.node_sound_metal_defaults()
-elseif industrialtest.mclAvailable then
-	definition.groups={
-		pickaxey=1,
-		handy=1
-	}
-	definition.sounds=mcl_sounds.node_sound_metal_defaults()
-	definition._mcl_blast_resistance=1
-	definition._mcl_hardness=1
-end
-minetest.register_node("industrialtest:mining_pipe",definition)
-
-minetest.register_craft({
-	type="shaped",
-	output="industrialtest:mining_pipe 8",
-	recipe={
-		{"industrialtest:refined_iron_ingot","","industrialtest:refined_iron_ingot"},
-		{"industrialtest:refined_iron_ingot","","industrialtest:refined_iron_ingot"},
-		{"industrialtest:refined_iron_ingot",industrialtest.elementKeys.treetap,"industrialtest:refined_iron_ingot"}
-	}
-})
-
-industrialtest.Miner=table.copy(industrialtest.ElectricMachine)
-industrialtest.internal.unpackTableInto(industrialtest.Miner,{
-	name="industrialtest:miner",
-	description=S("Miner"),
-	tiles={
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_miner_front.png"
-	},
-	sounds="metal",
-	storageLists={
-		"drill",
-		"src",
-		"scanner",
-		"dst",
-		"powerStorage",
-		"upgrades"
-	},
-	powerLists={
-		{
-			list="powerStorage",
-			direction="i"
-		}
-	},
-	requiresWrench=true,
-	facedir=true,
-	flow=industrialtest.api.lvPowerFlow,
-	capacity=5000,
-	ioConfig="iiiiii",
-	hasPowerInput=true,
-	_opPower=1000,
-	_scannerOpPower=10
-})
-
-function industrialtest.Miner.onConstruct(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	inv:set_size("drill",1)
-	inv:set_size("src",1)
-	inv:set_size("scanner",1)
-	inv:set_size("dst",15)
-	inv:set_size("powerStorage",1)
-	inv:set_size("upgrades",1)
-	meta:set_int("level",pos.y-1)
-	industrialtest.ElectricMachine.onConstruct(self,pos)
-end
-
-function industrialtest.Miner.onDestruct(self,pos)
-	destructMiningPipe(vector.new(pos.x,pos.y-1,pos.z),nil)
-	industrialtest.ElectricMachine.onDestruct(self,pos)
-end
-
-function industrialtest.Miner.onDig(self,pos,node,digger)
-	destructMiningPipe(vector.new(pos.x,pos.y-1,pos.z),digger)
-	return industrialtest.ElectricMachine.onDig(self,pos,node,digger)
-end
-
-function industrialtest.Miner.getFormspec(self,pos)
-	local parentFormspec=industrialtest.ElectricMachine.getFormspec(self,pos)
-	local meta=minetest.get_meta(pos)
-	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
-	local formspec={
-		"label[0.7,1.2;"..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").."]",
-		"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").."]",
-		"list[context;scanner;0.7,4.7;1,1]",
-		industrialtest.internal.getItemSlotBg(0.7,4.7,1,1),
-		"list[context;dst;2.28,1.9;5,3]",
-		industrialtest.internal.getItemSlotBg(2.28,1.9,5,3),
-		"list[context;upgrades;9.1,1.2;1,1]",
-		industrialtest.internal.getItemSlotBg(9.1,1.2,1,1),
-		(powerPercent>0 and "image[9.1,2.29;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
-		 or "image[9.1,2.29;1,1;industrialtest_gui_electricity_bg.png]"),
-		"list[context;powerStorage;9.1,3.5;1,1]",
-		industrialtest.internal.getItemSlotBg(9.1,3.5,1,1),
-		"listring[context;src]",
-		"listring[context;dst]"
-	}
-	return parentFormspec..table.concat(formspec,"")
-end
-
-function industrialtest.Miner.canUpdate(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local drillSlot=inv:get_stack("drill",1)
-	local srcSlot=inv:get_stack("src",1)
-	local level=meta:get_int("level")
-	local requiredPower=self:getRequiredPower(pos)
-	return meta:get_int("industrialtest.powerAmount")>=requiredPower and not drillSlot:is_empty() and not srcSlot:is_empty() and
-		self:canContinue(pos,level)
-end
-
-function industrialtest.Miner.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local itemstack=inv:get_stack(fromList,fromIndex)
-	if toList=="drill" then
-		return self.allowDrillPut(itemstack) and count or 0
-	end
-	if toList=="src" then
-		return itemstack:get_name()=="industrialtest:mining_pipe" and count or 0
-	end
-	if toList=="scanner" then
-		return self.allowScannerPut(itemstack) and 1 or 0
-	end
-	if toList=="dst" then
-		return 0
-	end
-	return industrialtest.ElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-end
-
-function industrialtest.Miner.allowMetadataInventoryPut(self,pos,listname,index,itemstack,player)
-	if listname=="drill" then
-		return self.allowDrillPut(itemstack) and itemstack:get_count() or 0
-	end
-	if listname=="src" then
-		return itemstack:get_name()=="industrialtest:mining_pipe" and itemstack:get_count() or 0
-	end
-	if listname=="scanner" then
-		return self.allowScannerPut(itemstack) and 1 or 0
-	end
-	if listname=="dst" then
-		return 0
-	end
-	return industrialtest.ElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,itemstack,player)
-end
-
-function industrialtest.Miner.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	self:onInventoryPut(pos,toList)
-	industrialtest.ElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-end
-
-function industrialtest.Miner.onMetadataInventoryPut(self,pos,listname,index,stack)
-	self:onInventoryPut(pos,listname)
-	industrialtest.ElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
-end
-
-function industrialtest.Miner.onMetadataInventoryTake(self,pos,listname,index,stack)
-	if listname=="dst" then
-		self:triggerIfNeeded(pos)
-	end
-end
-
-function industrialtest.Miner.update(self,pos,elapsed,meta,inv)
-	if not self:canUpdate(pos) then
-		return false,false
-	end
-
-	local level=meta:get_int("level")
-	if not self:canContinue(pos,level) then
-		return false,false
-	end
-
-	local srcSlot=inv:get_stack("src",1)
-	srcSlot:take_item(1)
-	inv:set_stack("src",1,srcSlot)
-	local targetPos=vector.new(pos.x,level,pos.z)
-	local drop=self.getNodeDrop(targetPos)
-	self.placeMiningPipe(pos,targetPos)
-	inv:add_item("dst",drop)
-
-	local scannerSlot=inv:get_stack("scanner",1)
-	if not scannerSlot:is_empty() then
-		local def=scannerSlot:get_definition()
-		if def and def._industrialtest_self then
-			local filtered=def._industrialtest_self:filter(targetPos)
-			for _,filteredPos in ipairs(filtered) do
-				drop=self.getNodeDrop(filteredPos)
-				if inv:room_for_item("dst",drop) then
-					minetest.remove_node(filteredPos)
-					inv:add_item("dst",drop)
-				end
-			end
-		end
-	end
-
-	local requiredPower=self:getRequiredPower(pos)
-	meta:set_int("level",level-1)
-	industrialtest.api.addPower(meta,-requiredPower)
-
-	return true,true
-end
-
-function industrialtest.Miner.onInventoryPut(self,pos,listname)
-	if listname=="drill" or listname=="src" then
-		self:triggerIfNeeded(pos)
-	end
-end
-
-function industrialtest.Miner.allowDrillPut(itemstack)
-	local def=itemstack:get_definition()
-	return def and def.groups and def.groups._industrialtest_miningDrill
-end
-
-function industrialtest.Miner.allowScannerPut(itemstack)
-	local def=itemstack:get_definition()
-	return def and def.groups and def.groups._industrialtest_scanner
-end
-
-function industrialtest.Miner.canContinue(self,pos,level)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local targetPos=vector.new(pos.x,level,pos.z)
-	local targetNode=minetest.get_node(targetPos)
-	if targetNode.name=="ignore" then
-		minetest.load_area(targetPos)
-		targetNode=minetest.get_node(targetPos)
-		if targetNode.name=="ignore" then
-			return false
-		end
-	end
-
-	local def=minetest.registered_nodes[targetNode.name]
-	local drop=self.getNodeDrop(vector.new(pos.x,level,pos.z))
-	return not (def and def.groups and def.groups.unbreakable) and inv:room_for_item("dst",drop)
-end
-
-function industrialtest.Miner.getRequiredPower(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local scannerSlot=inv:get_stack("scanner",1)
-	local result=self._opPower
-	if not scannerSlot:is_empty() then
-		local def=scannerSlot:get_definition()
-		if def and def._industrialtest_self then
-			local distance=def._industrialtest_self.minerDistance or 0
-			result=result+(distance*distance-1)*self._scannerOpPower
-		end
-	end
-	return result
-end
-
-function industrialtest.Miner.getNodeDrop(pos)
-	local node=minetest.get_node(pos)
-	local def=minetest.registered_nodes[node.name]
-	if not def.pointable then
-		return ItemStack()
-	end
-	return ItemStack((def and def.drop and def.drop~="") and def.drop or node.name)
-end
-
-function industrialtest.Miner.placeMiningPipe(minerPos,pos)
-	minetest.add_node(pos,{
-		name="industrialtest:mining_pipe"
-	})
-	local meta=minetest.get_meta(pos)
-	meta:set_string("miner",minetest.serialize(minerPos))
-end
-
-industrialtest.Miner:register()
-
-minetest.register_craft({
-	type="shaped",
-	output="industrialtest:miner",
-	recipe={
-		{"",industrialtest.elementKeys.chest,""},
-		{"industrialtest:electronic_circuit","industrialtest:machine_block","industrialtest:electronic_circuit"},
-		{"","industrialtest:mining_pipe",""}
-	}
-})

machines/nuclear_reactor.lua

@@ -15,234 +15,60 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.Reactor=table.copy(industrialtest.ActivatedElectricMachine)
+local reactor={}
-industrialtest.internal.unpackTableInto(industrialtest.Reactor,{
+local reactorChamber={}
-	name="industrialtest:nuclear_reactor",
-	description=S("Nuclear Reactor"),
-	tiles={
-		"industrialtest_machine_block.png^industrialtest_nuclear_reactor_top.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_nuclear_reactor_front.png"
-	},
-	sounds="metal",
-	requiresWrench=true,
-	facedir=true,
-	storageLists={
-		"charged",
-		"fuel"
-	},
-	powerLists={
-		{
-			list="charged",
-			direction="o"
-		}
-	},
-	active={
-		tiles={
-			"industrialtest_machine_block.png^industrialtest_nuclear_reactor_top.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png^industrialtest_nuclear_reactor_front_active.png"
-		},
-		lightSource=2
-	},
-	capacity=industrialtest.api.evPowerFlow,
-	flow=industrialtest.api.evPowerFlow,
-	hasPowerOutput=true,
-	ioConfig="oooooo"
-})
 
-function industrialtest.Reactor.onConstruct(self,pos)
+reactor.getFormspec=function(pos)
 	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
+	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
+	local size=math.floor(meta:get_int("size")/3)
+	local switchText=(meta:get_int("enabled")==0 and S("Start") or S("Stop"))
+	local formspec
+	if industrialtest.mtgAvailable then
+		formspec={
+			"list[context;fuel;1,1;"..size..","..size.."]",
+			"listring[context;fuel]",
+			"list[context;charged;7.7,2.8;1,1]",
+			"listring[context;charged]",
+			"button[7.7,1;1,0.8;toggle;"..minetest.formspec_escape(switchText).."]",
+			"box[9,1;0.3,4.8;#202020]",
+			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or ""),
+		}
+	elseif industrialtest.mclAvailable then
+		formspec={
+			"list[context;fuel;1,1;"..size..","..size.."]",
+			mcl_formspec.get_itemslot_bg(1,1,size,size),
+			"listring[context;fuel]",
+			"list[context;charged;7,2.8;1,1]",
+			mcl_formspec.get_itemslot_bg(7.7,2.8,1,1),
+			"listring[context;charged]",
+			"button[7.7,1;1,0.8;toggle;"..minetest.formspec_escape(switchText).."]",
+			"box[9,1;0.3,4.8;#202020]",
+			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or "")
+		}
+	end
+	return table.concat(formspec,"")
+end
+
+reactor.onConstruct=function(pos,meta,inv)
 	inv:set_size("fuel",4)
 	inv:set_size("charged",1)
 	meta:set_int("heat",0)
 	meta:set_int("size",6)
 	meta:set_int("enabled",0)
 	meta:set_int("stateChanged",0)
-	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
 end
 
-function industrialtest.Reactor.onDestruct(self,pos)
+reactor.onDestruct=function(pos)
 	local meta=minetest.get_meta(pos)
 	local chambers=minetest.deserialize(meta:get_string("chambers")) or {}
 	for _,chamber in ipairs(chambers) do
 		minetest.remove_node(chamber)
 		minetest.add_item(chamber,"industrialtest:nuclear_reactor_chamber")
 	end
-	industrialtest.ActivatedElectricMachine.onDestruct(self,pos)
 end
 
-function industrialtest.Reactor.getFormspec(self,pos)
+local function hasFuel(fuelList)
-	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
-	local meta=minetest.get_meta(pos)
-	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
-	local size=math.floor(meta:get_int("size")/3)
-	local switchText=(meta:get_int("enabled")==0 and S("Start") or S("Stop"))
-	local formspec={
-		"list[context;fuel;1,1;"..size..","..size.."]",
-		industrialtest.internal.getItemSlotBg(1,1,size,size),
-		"list[context;charged;7,2.8;1,1]",
-		industrialtest.internal.getItemSlotBg(7.7,2.8,1,1),
-		"button[7.7,1;1,0.8;toggle;"..minetest.formspec_escape(switchText).."]",
-		self.createPowerIndicatorWidget(charged,9,1),
-		"listring[context;fuel]"
-	}
-	return parentFormspec..table.concat(formspec,"")
-end
-
-function industrialtest.Reactor.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local movedItemStack=inv:get_stack(fromList,fromIndex)
-	local def=movedItemStack:get_definition()
-	if toList=="fuel" and (not def or not def.groups._industrialtest_placedInNuclearReactor) then
-		return 0
-	end
-	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-end
-
-function industrialtest.Reactor.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
-	local def=stack:get_definition()
-	if listname=="fuel" and (not def or not def.groups._industrialtest_placedInNuclearReactor) then
-		return 0
-	end
-	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
-end
-
-function industrialtest.Reactor.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	self.synchronizeChambers(pos)
-end
-
-function industrialtest.Reactor.onMetadataInventoryPut(self,pos,listname,index,stack,player)
-	industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
-	self.synchronizeChambers(pos)
-end
-
-function industrialtest.Reactor.onMetadataInventoryTake(self,pos,listname,index,stack)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryTake(self,pos,listname,index,stack)
-	self.synchronizeChambers(pos)
-end
-
-function industrialtest.Reactor.onReceiveFields(self,pos,formname,fields)
-	if not fields.toggle then
-		return
-	end
-	local meta=minetest.get_meta(pos)
-	if not self.hasFuel(pos) and meta:get_int("enabled")==0 then
-		return
-	end
-	if meta:get_int("enabled")==0 then
-		meta:set_int("enabled",1)
-	else
-		meta:set_int("enabled",0)
-		self:updateFormspec(pos)
-		self.synchronizeChambers(pos)
-	end
-	meta:set_int("stateChanged",1)
-	self:triggerIfNeeded(pos)
-end
-
-function industrialtest.Reactor.shouldActivate(self,pos)
-	local meta=minetest.get_meta(pos)
-
-	if meta:get_int("stateChanged")==0 then
-		return false
-	end
-
-	return meta:get_int("enabled")>0 and self.hasFuel(pos)
-end
-
-function industrialtest.Reactor.shouldDeactivate(self,pos)
-	local meta=minetest.get_meta(pos)
-	return meta:get_int("enabled")==0 or not self.hasFuel(pos)
-end
-
-function industrialtest.Reactor.afterActivation(self,pos)
-	local meta=minetest.get_meta(pos)
-	meta:set_int("stateChanged",0)
-	self.synchronizeChambers(pos)
-end
-
-function industrialtest.Reactor.afterDeactivation(self,pos)
-	local meta=minetest.get_meta(pos)
-	meta:set_int("enabled",0)
-	self:updateFormspec(pos)
-	self.synchronizeChambers(pos)
-end
-
-function industrialtest.Reactor.activeUpdate(self,pos,elapsed,meta,inv)
-	local size=math.floor(meta:get_int("size")/3)
-	local fuelList=inv:get_list("fuel")
-	local shouldRerunTimer=meta:get_int("enabled")>0
-	local shouldUpdateFormspec=false
-
-	local maxCluster=self.findMaxFuelCluster(size,fuelList)
-	for _,stack in ipairs(maxCluster) do
-		local index=stack.y*size+stack.x
-		local usedStack,_=self.useFuel(fuelList[index],5)
-		inv:set_stack("fuel",index,usedStack)
-	end
-	local generatedPowerAmount=math.pow(3,#maxCluster)
-	if industrialtest.api.addPower(meta,generatedPowerAmount)>0 then
-		shouldUpdateFormspec=true
-	end
-
-	local heat=meta:get_int("heat")+#maxCluster
-	local coolant=self.findCoolant(fuelList)
-	if coolant>0 then
-		local coolantStack,used=self.useFuel(fuelList[coolant],#maxCluster*50)
-		heat=math.max(0,heat-used)
-		inv:set_stack("fuel",coolant,coolantStack)
-	end
-	if heat>200 then
-		minetest.remove_node(pos)
-		industrialtest.internal.explode(pos,#maxCluster*4)
-		return false
-	end
-	meta:set_int("heat",heat)
-
-	self.synchronizeChambers(pos)
-
-	return shouldUpdateFormspec
-end
-
-function industrialtest.Reactor.changeSize(self,pos,diff)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local size=meta:get_int("size")+diff
-	local actualSize=math.floor(size/3)
-	meta:set_int("size",size)
-	inv:set_size("fuel",actualSize*actualSize)
-	self:updateFormspec(pos)
-end
-
-function industrialtest.Reactor.synchronizeToChamber(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local fuelList=inv:get_list("fuel")
-	local chargedList=inv:get_list("charged")
-
-	local reactorPos=minetest.deserialize(meta:get_string("reactor"))
-	local reactorMeta=minetest.get_meta(reactorPos)
-	local reactorInv=reactorMeta:get_inventory()
-	reactorInv:set_list("fuel",fuelList)
-	reactorInv:set_list("charged",chargedList)
-
-	self.synchronizeChambers(reactorPos)
-end
-
-function industrialtest.Reactor.hasFuel(pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local fuelList=inv:get_list("fuel")
 	for _,stack in ipairs(fuelList) do
 		if stack:get_name()=="industrialtest:uranium_cell" then
 			return true
@@ -251,7 +77,7 @@ function industrialtest.Reactor.hasFuel(pos)
 	return false
 end
 
-function industrialtest.Reactor.findMaxFuelCluster(size,fuelList)
+local function findMaxFuelCluster(size,fuelList)
 	local maxCluster={}
 	for y=1,size do
 		for x=1,size do
@@ -325,7 +151,7 @@ function industrialtest.Reactor.findMaxFuelCluster(size,fuelList)
 	return maxCluster
 end
 
-function industrialtest.Reactor.findCoolant(fuelList)
+local function findCoolant(fuelList)
 	for i=1,#fuelList do
 		local stack=fuelList[i]
 		local def=minetest.registered_tools[stack:get_name()]
@@ -336,7 +162,7 @@ function industrialtest.Reactor.findCoolant(fuelList)
 	return 0
 end
 
-function industrialtest.Reactor.useFuel(stack,use)
+local function useFuel(stack,use)
 	local used=math.min(65535-stack:get_wear(),use)
 	if used<use then
 		stack:replace("industrialtest:empty_cell")
@@ -346,67 +172,197 @@ function industrialtest.Reactor.useFuel(stack,use)
 	return stack,used
 end
 
-function industrialtest.Reactor.synchronizeChambers(pos)
+reactor.onTimer=function(pos,elapsed,meta,inv)
-	local meta=minetest.get_meta(pos)
+	local powerFlow=meta:get_int("industrialtest.powerFlow")
-	local chambers=meta:contains("chambers") and minetest.deserialize(meta:get_string("chambers")) or {}
+	local chargedSlot=inv:get_stack("charged",1)
-	for _,chamber in ipairs(chambers) do
+	local fuelList=inv:get_list("fuel")
-		industrialtest.ReactorChamber:synchronize(chamber,pos)
+	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
-	end
+	local shouldRerunTimer=meta:get_int("enabled")>0
+	local shouldUpdateFormspec=false
+
+	if chargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(chargedSlot:get_meta()) and meta:get_int("industrialtest.powerAmount")>0 then
+		industrialtest.api.transferPowerToItem(meta,chargedSlot,powerFlow)
+		inv:set_stack("charged",1,chargedSlot)
+		shouldUpdateFormspec=true
+		shouldRerunTimer=true
 	end
 
-industrialtest.Reactor:register()
+	if meta:get_int("stateChanged")>0 then
+		shouldUpdateFormspec=true
+		meta:set_int("stateChanged",0)
+	end
 
-minetest.register_craft({
+	if meta:get_int("enabled")>0 and hasFuel(fuelList) then
-	type="shaped",
+		minetest.swap_node(pos,{
-	output="industrialtest:nuclear_reactor",
+			name="industrialtest:nuclear_reactor_active",
-	recipe={
+			param2=minetest.get_node(pos).param2
-		{"","industrialtest:advanced_electronic_circuit",""},
-		{"industrialtest:nuclear_reactor_chamber","industrialtest:nuclear_reactor_chamber","industrialtest:nuclear_reactor_chamber"},
-		{"","industrialtest:generator",""}
-	}
 		})
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		shouldRerunTimer=false
+	end
 
-industrialtest.ReactorChamber=table.copy(industrialtest.Machine)
+	reactor.synchronizeChambers(pos)
-industrialtest.internal.unpackTableInto(industrialtest.ReactorChamber,{
+
-	name="industrialtest:nuclear_reactor_chamber",
+	return shouldRerunTimer,shouldUpdateFormspec
-	description=S("Nuclear Reactor Chamber"),
+end
-	tiles={"industrialtest_machine_block.png^industrialtest_nuclear_reactor_top.png"},
+
-	sounds="metal",
+reactor.activeOnTimer=function(pos,elapsed,meta,inv)
-	storageLists={
+	local powerFlow=meta:get_int("industrialtest.powerFlow")
-		"charged",
+	local size=math.floor(meta:get_int("size")/3)
-		"fuel"
+	local chargedSlot=inv:get_stack("charged",1)
-	},
+	local fuelList=inv:get_list("fuel")
-	requiresWrench=true
+	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
+	local shouldRerunTimer=meta:get_int("enabled")>0
+	local shouldUpdateFormspec=false
+
+	if chargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(chargedSlot:get_meta()) and meta:get_int("industrialtest.powerAmount")>0 then
+		industrialtest.api.transferPowerToItem(meta,chargedSlot,powerFlow)
+		inv:set_stack("charged",1,chargedSlot)
+		shouldUpdateFormspec=true
+		shouldRerunTimer=true
+	end
+
+	if meta:get_int("stateChanged")>0 then
+		shouldUpdateFormspec=true
+		meta:set_int("stateChanged",0)
+	end
+
+	if meta:get_int("enabled")==0 or not hasFuel(fuelList) then
+		minetest.swap_node(pos,{
+			name="industrialtest:nuclear_reactor",
+			param2=minetest.get_node(pos).param2
 		})
+		meta:set_int("enabled",0)
+		reactor.synchronizeChambers(pos)
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		return false,shouldUpdateFormspec
+	end
 
-function industrialtest.ReactorChamber.onDestruct(self,pos)
+	local maxCluster=findMaxFuelCluster(size,fuelList)
-	industrialtest.Machine.onDestruct(self,pos)
+	for _,stack in ipairs(maxCluster) do
+		local index=stack.y*size+stack.x
+		local usedStack,_=useFuel(fuelList[index],5)
+		inv:set_stack("fuel",index,usedStack)
+	end
+	local generatedPowerAmount=math.pow(3,#maxCluster)
+	if industrialtest.api.addPower(meta,generatedPowerAmount)>0 then
+		shouldUpdateFormspec=true
+	end
 
+	local heat=meta:get_int("heat")+#maxCluster
+	local coolant=findCoolant(fuelList)
+	if coolant>0 then
+		local coolantStack,used=useFuel(fuelList[coolant],#maxCluster*50)
+		heat=math.max(0,heat-used)
+		inv:set_stack("fuel",coolant,coolantStack)
+	end
+	if heat>200 then
+		minetest.remove_node(pos)
+		industrialtest.internal.explode(pos,#maxCluster*4)
+		return false,false
+	end
+	meta:set_int("heat",heat)
+
+	reactor.synchronizeChambers(pos)
+
+	return shouldRerunTimer,shouldUpdateFormspec
+end
+
+reactor.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
 	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local movedItemStack=inv:get_stack(fromList,fromIndex)
+	local def=minetest.registered_tools[movedItemStack:get_name()]
+	if toList=="fuel" and (not def or not def.groups._industrialtest_placedInNuclearReactor) then
+		return 0
+	end
+	return count
+end
 
-	if not meta:contains("reactor") then
+reactor.allowMetadataInventoryPut=function(pos,listname,index,stack)
+	local def=minetest.registered_tools[stack:get_name()]
+	if listname=="fuel" and (not def or not def.groups._industrialtest_placedInNuclearReactor) then
+		return 0
+	end
+	return stack:get_count()
+end
+
+reactor.metadataChange=function(pos)
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+	reactor.synchronizeChambers(pos)
+end
+
+reactor.handleFormspecFields=function(pos,formname,fields)
+	if not fields.toggle then
 		return
 	end
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local fuelList=inv:get_list("fuel")
+	if not hasFuel(fuelList) and meta:get_int("enabled")==0 then
+		return
+	end
+	if meta:get_int("enabled")==0 then
+		meta:set_int("enabled",1)
+	else
+		meta:set_int("enabled",0)
+	end
+	meta:set_int("stateChanged",1)
+	reactor.metadataChange(pos)
+end
+
+reactor.synchronizeToChamber=function(pos)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local fuelList=inv:get_list("fuel")
+	local chargedList=inv:get_list("charged")
 
 	local reactorPos=minetest.deserialize(meta:get_string("reactor"))
 	local reactorMeta=minetest.get_meta(reactorPos)
-	if not reactorMeta or not reactorMeta:contains("chambers") then
+	local reactorInv=reactorMeta:get_inventory()
-		return
+	reactorInv:set_list("fuel",fuelList)
-	end
+	reactorInv:set_list("charged",chargedList)
-	local chambers=minetest.deserialize(reactorMeta:get_string("chambers"))
-	for i,chamber in ipairs(chambers) do
-		if chamber.x==pos.x and chamber.y==pos.y and chamber.z==pos.z then
-			table.remove(chambers,i)
-			break
-		end
-	end
-	reactorMeta:set_string("chambers",minetest.serialize(chambers))
 
-	industrialtest.Reactor:changeSize(reactorPos,-1)
+	reactor.synchronizeChambers(reactorPos)
-	industrialtest.Reactor.synchronizeChambers(reactorPos)
 end
 
-function industrialtest.ReactorChamber.afterPlaceNode(self,pos)
+reactor.synchronizeChambers=function(pos)
+	local meta=minetest.get_meta(pos)
+	local chambers=meta:contains("chambers") and minetest.deserialize(meta:get_string("chambers")) or {}
+	for _,chamber in ipairs(chambers) do
+		reactorChamber.synchronize(chamber,pos)
+	end
+end
+
+reactor.changeSize=function(pos,diff)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local size=meta:get_int("size")+diff
+	local actualSize=math.floor(size/3)
+	meta:set_int("size",size)
+	inv:set_size("fuel",actualSize*actualSize)
+
+	local def=minetest.registered_nodes[minetest.get_node(pos).name]
+	def._industrialtest_updateFormspec(pos)
+end
+
+reactorChamber.synchronize=function(pos,reactor)
+	local meta=minetest.get_meta(pos)
+	local inv=meta:get_inventory()
+	local reactorDef=minetest.registered_nodes[minetest.get_node(reactor).name]
+	meta:set_string("formspec",reactorDef._industrialtest_getFormspec(reactor))
+
+	local reactorMeta=minetest.get_meta(reactor)
+	local reactorInv=reactorMeta:get_inventory()
+	local fuelList=reactorInv:get_list("fuel")
+	local chargedList=reactorInv:get_list("charged")
+	inv:set_size("fuel",#fuelList)
+	inv:set_size("charged",#chargedList)
+	inv:set_list("fuel",fuelList)
+	inv:set_list("charged",chargedList)
+end
+
+reactorChamber.afterPlaceNode=function(pos)
 	local neighbours={
 		vector.offset(pos,-1,0,0),
 		vector.offset(pos,1,0,0),
@@ -430,8 +386,8 @@ function industrialtest.ReactorChamber.afterPlaceNode(self,pos)
 	local meta=minetest.get_meta(pos)
 	meta:set_string("reactor",minetest.serialize(reactorPos))
 
-	industrialtest.Reactor:changeSize(reactorPos,1)
+	reactor.changeSize(reactorPos,1)
-	industrialtest.Reactor.synchronizeChambers(reactorPos)
+	reactor.synchronizeChambers(reactorPos)
 
 	local reactorMeta=minetest.get_meta(reactorPos)
 	local chambers=reactorMeta:contains("chambers") and minetest.deserialize(reactorMeta:get_string("chambers")) or {}
@@ -440,72 +396,129 @@ function industrialtest.ReactorChamber.afterPlaceNode(self,pos)
 
 	industrialtest.api.createNetworkMapForNode(reactorPos)
 
-	self:synchronize(pos,reactorPos)
+	reactorChamber.synchronize(pos,reactorPos)
 end
 
-function industrialtest.ReactorChamber.getFormspec(self,pos)
+reactorChamber.onDestruct=function(pos)
 	local meta=minetest.get_meta(pos)
 	if not meta:contains("reactor") then
-		return ""
+		return
 	end
-
 	local reactorPos=minetest.deserialize(meta:get_string("reactor"))
-	return industrialtest.Reactor:getFormspec(reactorPos)
+	local reactorMeta=minetest.get_meta(reactorPos)
+	if not reactorMeta or not reactorMeta:contains("chambers") then
+		return
+	end
+	local chambers=minetest.deserialize(reactorMeta:get_string("chambers"))
+	for i,chamber in ipairs(chambers) do
+		if chamber.x==pos.x and chamber.y==pos.y and chamber.z==pos.z then
+			table.remove(chambers,i)
+			break
+		end
+	end
+	reactorMeta:set_string("chambers",minetest.serialize(chambers))
+	reactor.changeSize(reactorPos,-1)
+	reactor.synchronizeChambers(reactorPos)
 end
 
-function industrialtest.ReactorChamber.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+reactorChamber.handleFormspecFields=function(pos,formname,fields)
-	return industrialtest.Reactor:allowMetadataInventoryMove(pos,fromList,fromIndex,toList,toIndex,count)
-end
-
-function industrialtest.ReactorChamber.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
-	return industrialtest.Reactor:allowMetadataInventoryPut(pos,listname,index,stack,player)
-end
-
-function industrialtest.ReactorChamber.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	industrialtest.Machine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	industrialtest.Reactor:synchronizeToChamber(pos)
-end
-
-function industrialtest.ReactorChamber.onMetadataInventoryPut(self,pos,listname,index,stack,player)
-	industrialtest.Machine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
-	industrialtest.Reactor:synchronizeToChamber(pos)
-end
-
-function industrialtest.ReactorChamber.onMetadataInventoryTake(self,pos,listname,index,stack)
-	industrialtest.Machine.onMetadataInventoryTake(self,pos,listname,index,stack)
-	industrialtest.Reactor:synchronizeToChamber(pos)
-end
-
-function industrialtest.ReactorChamber.onReceiveFields(self,pos,formname,fields)
 	local meta=minetest.get_meta(pos)
 	local reactorPos=minetest.deserialize(meta:get_string("reactor"))
-	industrialtest.Reactor:onReceiveFields(reactorPos,formname,fields)
+	reactor.handleFormspecFields(reactorPos,formname,fields)
 end
 
-function industrialtest.ReactorChamber.createDefinitionTable(self)
+industrialtest.internal.registerMachine({
-	local def=industrialtest.Machine.createDefinitionTable(self)
+	name="nuclear_reactor",
-	def.groups._industrialtest_cable=1
+	displayName=S("Nuclear Reactor"),
-	def._industrialtest_cableFlow=industrialtest.api.evPowerFlow
+	getFormspec=reactor.getFormspec,
-	return def
+	capacity=industrialtest.api.evPowerFlow,
+	flow=industrialtest.api.evPowerFlow,
+	ioConfig="oooooo",
+	requiresWrench=true,
+	registerActiveVariant=true,
+	powerSlots={"charged"},
+	storageSlots={"charged","fuel"},
+	sounds="metal",
+	groups={
+		_industrialtest_hasPowerOutput=1
+	},
+	customKeys={
+		tiles={
+			"industrialtest_machine_block.png^industrialtest_nuclear_reactor_top.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png^industrialtest_nuclear_reactor_front.png",
+			"industrialtest_machine_block.png"
+		},
+		paramtype2="facedir",
+		legacy_facedir_simple=true,
+		on_receive_fields=reactor.handleFormspecFields,
+		_industrialtest_synchronizeToChamber=reactor.synchronizeToChamber
+	},
+	activeCustomKeys={
+		tiles={
+			"industrialtest_machine_block.png^industrialtest_nuclear_reactor_top.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png^industrialtest_nuclear_reactor_front_active.png",
+			"industrialtest_machine_block.png"
+		},
+		light_source=2,
+		on_receive_fields=reactor.handleFormspecFields
+	},
+	onConstruct=reactor.onConstruct,
+	onDestruct=reactor.onDestruct,
+	onTimer=reactor.onTimer,
+	activeOnTimer=reactor.activeOnTimer,
+	allowMetadataInventoryMove=reactor.allowMetadataInventoryMove,
+	allowMetadataInventoryPut=reactor.allowMetadataInventoryPut,
+	onMetadataInventoryMove=reactor.metadataChange,
+	onMetadataInventoryPut=reactor.metadataChange,
+	onMetadataInventoryTake=reactor.metadataChange
+})
+minetest.register_craft({
+	type="shaped",
+	output="industrialtest:nuclear_reactor",
+	recipe={
+		{"","industrialtest:advanced_electronic_circuit",""},
+		{"industrialtest:nuclear_reactor_chamber","industrialtest:nuclear_reactor_chamber","industrialtest:nuclear_reactor_chamber"},
+		{"","industrialtest:generator",""}
+	}
+})
+
+local definition={
+	description=S("Nuclear Reactor Chamber"),
+	tiles={"industrialtest_machine_block.png^industrialtest_nuclear_reactor_top.png"},
+	drop="industrialtest:machine_block",
+	groups={
+		_industrialtest_wrenchUnmountable=1,
+		_industrialtest_cable=1
+	},
+	on_destruct=reactorChamber.onDestruct,
+	after_place_node=reactorChamber.afterPlaceNode,
+	can_dig=minetest.registered_nodes["industrialtest:nuclear_reactor"].can_dig,
+	on_receive_fields=reactorChamber.handleFormspecFields,
+	allow_metadata_inventory_move=minetest.registered_nodes["industrialtest:nuclear_reactor"].allow_metadata_inventory_move,
+	allow_metadata_inventory_put=minetest.registered_nodes["industrialtest:nuclear_reactor"].allow_metadata_inventory_put,
+	on_metadata_inventory_move=reactor.synchronizeToChamber,
+	on_metadata_inventory_put=reactor.synchronizeToChamber,
+	on_metadata_inventory_take=reactor.synchronizeToChamber,
+	_industrialtest_cableFlow=industrialtest.api.evPowerFlow
+}
+if industrialtest.mtgAvailable then
+	definition.sounds=default.node_sound_metal_defaults()
+	definition.groups.cracky=1
+	definition.groups.level=2
+elseif industrialtest.mclAvailable then
+	definition.sounds=mcl_sounds.node_sound_metal_defaults()
+	definition._mcl_blast_resistance=6
+	definition._mcl_hardness=5
 end
-
+minetest.register_node("industrialtest:nuclear_reactor_chamber",definition)
-function industrialtest.ReactorChamber.synchronize(self,pos,reactor)
-	self:updateFormspec(pos)
-
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local reactorMeta=minetest.get_meta(reactor)
-	local reactorInv=reactorMeta:get_inventory()
-	local fuelList=reactorInv:get_list("fuel")
-	local chargedList=reactorInv:get_list("charged")
-	inv:set_size("fuel",#fuelList)
-	inv:set_size("charged",#chargedList)
-	inv:set_list("fuel",fuelList)
-	inv:set_list("charged",chargedList)
-end
-
-industrialtest.ReactorChamber:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:nuclear_reactor_chamber",

machines/power_storage.lua

@@ -15,73 +15,121 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.PowerStorage=table.copy(industrialtest.ElectricMachine)
+local powerStorage={}
-industrialtest.internal.unpackTableInto(industrialtest.PowerStorage,{
-	facedir=true,
-	storageLists={
-		"charged",
-		"discharged"
-	},
-	powerLists={
-		{
-			list="charged",
-			direction="o"
-		},
-		{
-			list="discharged",
-			direction="i"
-		}
-	},
-	hasPowerInput=true,
-	hasPowerOutput=true,
-	ioConfig="iiiioi"
-})
 
-function industrialtest.PowerStorage.onConstruct(self,pos)
+powerStorage.getFormspec=function(pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	inv:set_size("charged",1)
-	inv:set_size("discharged",1)
-	industrialtest.ElectricMachine.onConstruct(self,pos)
-end
-
-function industrialtest.PowerStorage.getFormspec(self,pos)
-	local parentFormspec=industrialtest.ElectricMachine.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	local charged=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")
-	local formspec={
+	local formspec
+	if industrialtest.mtgAvailable then
+		formspec={
 			"list[context;charged;1,2.5;1,1]",
-		industrialtest.internal.getItemSlotBg(1,2.5,1,1),
+			"listring[context;charged]",
 			"label[0.9,3.9;"..S("Charge").."]",
 			"list[context;discharged;3,2.5;1,1]",
-		industrialtest.internal.getItemSlotBg(3,2.5,1,1),
+			"listring[context;discharged]",
 			"label[2.7,3.9;"..S("Discharge").."]",
-		self.createPowerIndicatorWidget(charged,9,1),
+			"box[9,1;0.3,4.8;#202020]",
-		"listring[context;charged]",
+			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or "")
-		"listring[context;discharged]"
 		}
-	return parentFormspec..table.concat(formspec,"")
+	elseif industrialtest.mclAvailable then
+		formspec={
+			"list[context;charged;1,2.5;1,1]",
+			"listring[context;charged]",
+			mcl_formspec.get_itemslot_bg(1,2.5,1,1),
+			"label[0.9,3.9;"..S("Charge").."]",
+			"list[context;discharged;3,2.5;1,1]",
+			"listring[context;discharged]",
+			mcl_formspec.get_itemslot_bg(3,2.5,1,1),
+			"label[2.7,3.9;"..S("Discharge").."]",
+			"box[9,1;0.3,4.8;#202020]",
+			(charged>0 and "box[9,"..(1+4.8-(charged*4.8))..";0.3,"..(charged*4.8)..";#FF1010]" or "")
+		}
+	end
+	return table.concat(formspec,"")
 end
 
-industrialtest.BatBox=table.copy(industrialtest.PowerStorage)
+powerStorage.onConstruct=function(pos,meta,inv)
-industrialtest.internal.unpackTableInto(industrialtest.BatBox,{
+	inv:set_size("charged",1)
-	name="industrialtest:batbox",
+	inv:set_size("discharged",1)
-	description=S("BatBox"),
+end
-	tiles={
+
-		"industrialtest_wood_machine_block.png",
+powerStorage.onTimer=function(pos,elapsed,meta,inv,config)
-		"industrialtest_wood_machine_block.png",
+	local chargedSlot=inv:get_stack("charged",1)
-		"industrialtest_wood_machine_block.png",
+	local dischargedSlot=inv:get_stack("discharged",1)
-		"industrialtest_wood_machine_block.png",
+	local afterFlow,flowTransferred=industrialtest.api.powerFlow(pos)
-		"industrialtest_wood_machine_block.png",
+	local shouldUpdateFormspec=flowTransferred
-		"industrialtest_wood_machine_block.png^industrialtest_batbox_front.png"
+	local shouldRerunTimer=(afterFlow and meta:get_int("industrialtest.powerAmount")>0)
+
+	if chargedSlot:get_count()>0 and meta:get_int("industrialtest.powerAmount")>0 and industrialtest.api.transferPowerToItem(meta,chargedSlot,config.flow)>0 then
+		inv:set_stack("charged",1,chargedSlot)
+		shouldRerunTimer=true
+		shouldUpdateFormspec=true
+	end
+	if dischargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(meta) and industrialtest.api.transferPowerFromItem(dischargedSlot,meta,config.flow)>0 then
+		inv:set_stack("discharged",1,dischargedSlot)
+		shouldRerunTimer=true
+		shouldUpdateFormspec=true
+	end
+
+	return shouldRerunTimer,shouldUpdateFormspec
+end
+
+powerStorage.onMetadataInventoryPut=function(pos)
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+end
+
+powerStorage.onMetadataInventoryMove=function(pos)
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+end
+
+local function registerPowerStorageNode(config)
+	industrialtest.internal.registerMachine({
+		name=config.name,
+		displayName=config.displayName,
+		capacity=config.capacity,
+		flow=config.flow,
+		ioConfig="iiiioi",
+		sounds=config.sounds,
+		powerSlots={"charged","discharged"},
+		storageSlots={"charged","discharged"},
+		registerActiveVariant=false,
+		groups={
+			_industrialtest_hasPowerOutput=1,
+			_industrialtest_hasPowerInput=1
 		},
-	sounds="wood",
+		customKeys={
-	capacity=25000,
+			tiles={
-	flow=industrialtest.api.lvPowerFlow
+				config.machineBlockTexture,
+				config.machineBlockTexture,
+				config.machineBlockTexture,
+				config.machineBlockTexture,
+				config.machineBlockTexture,
+				config.machineBlockTexture.."^industrialtest_"..config.name.."_front.png"
+			},
+			paramtype2="facedir",
+			legacy_facedir_simple=true
+		},
+		requiresWrench=config.requiresWrench,
+		getFormspec=powerStorage.getFormspec,
+		onConstruct=powerStorage.onConstruct,
+		onTimer=function(pos,elapsed,meta,inv)
+			return powerStorage.onTimer(pos,elapsed,meta,inv,config)
+		end,
+		onMetadataInventoryPut=powerStorage.onMetadataInventoryPut,
+		onMetadataInventoryMove=powerStorage.onMetadataInventoryMove
 	})
+end
 
-industrialtest.BatBox:register()
+registerPowerStorageNode({
-
+	name="batbox",
+	displayName=S("BatBox"),
+	capacity=25000,
+	flow=industrialtest.api.lvPowerFlow,
+	sounds="wood",
+	machineBlockTexture="industrialtest_wood_machine_block.png",
+	requiresWrench=false
+})
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:batbox",
@@ -92,25 +140,15 @@ minetest.register_craft({
 	}
 })
 
-industrialtest.CESU=table.copy(industrialtest.PowerStorage)
+registerPowerStorageNode({
-industrialtest.internal.unpackTableInto(industrialtest.CESU,{
+	name="cesu",
-	name="industrialtest:cesu",
+	displayName=S("CESU"),
-	description=S("CESU"),
-	tiles={
-		"industrialtest_bronze_machine_block.png",
-		"industrialtest_bronze_machine_block.png",
-		"industrialtest_bronze_machine_block.png",
-		"industrialtest_bronze_machine_block.png",
-		"industrialtest_bronze_machine_block.png",
-		"industrialtest_bronze_machine_block.png^industrialtest_cesu_front.png"
-	},
-	sounds="metal",
 	capacity=400000,
-	flow=industrialtest.api.mvPowerFlow
+	flow=industrialtest.api.mvPowerFlow,
+	sounds="metal",
+	machineBlockTexture="industrialtest_bronze_machine_block.png",
+	requiresWrench=false
 })
-
-industrialtest.CESU:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:cesu",
@@ -121,26 +159,15 @@ minetest.register_craft({
 	}
 })
 
-industrialtest.MFE=table.copy(industrialtest.PowerStorage)
+registerPowerStorageNode({
-industrialtest.internal.unpackTableInto(industrialtest.MFE,{
+	name="mfe",
-	name="industrialtest:mfe",
+	displayName=S("MFE"),
-	description=S("MFE"),
-	tiles={
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_mfe_front.png"
-	},
-	sounds="metal",
-	requiresWrench=true,
 	capacity=3000000,
-	flow=industrialtest.api.hvPowerFlow
+	flow=industrialtest.api.hvPowerFlow,
+	sounds="metal",
+	machineBlockTexture="industrialtest_machine_block.png",
+	requiresWrench=true
 })
-
-industrialtest.MFE:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:mfe",
@@ -151,27 +178,15 @@ minetest.register_craft({
 	}
 })
 
-
+registerPowerStorageNode({
-industrialtest.MFSU=table.copy(industrialtest.PowerStorage)
+	name="mfsu",
-industrialtest.internal.unpackTableInto(industrialtest.MFSU,{
+	displayName=S("MFSU"),
-	name="industrialtest:mfsu",
-	description=S("MFSU"),
-	tiles={
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png^industrialtest_mfsu_front.png"
-	},
-	sounds="metal",
-	requiresWrench=true,
 	capacity=30000000,
-	flow=industrialtest.api.evPowerFlow
+	flow=industrialtest.api.evPowerFlow,
+	sounds="metal",
+	machineBlockTexture="industrialtest_advanced_machine_block.png",
+	requiresWrench=false
 })
-
-industrialtest.MFSU:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:mfsu",

machines/recycler.lua

@@ -15,47 +15,18 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.Recycler=table.copy(industrialtest.SimpleElectricItemProcessor)
+
-industrialtest.internal.unpackTableInto(industrialtest.Recycler,{
+industrialtest.internal.registerSimpleElectricItemProcessor({
-	name="industrialtest:recycler",
+	name="recycler",
-	description=S("Recycler"),
+	displayName=S("Recycler"),
-	tiles={
+	customTopTexture=true,
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_recycler_front.png"
-	},
 	requiresWrench=true,
-	active={
-		tiles={
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png",
-			"industrialtest_machine_block.png^industrialtest_recycler_front_active.png"
-		}
-	},
 	capacity=80,
 	flow=industrialtest.api.lvPowerFlow,
 	opPower=40,
+	method="industrialtest.recycling",
 	efficiency=1
 })
-
-function industrialtest.Recycler.getCraftResult(self,itemstack)
-	local srcAfter=ItemStack(itemstack:get_name())
-	srcAfter:set_count(itemstack:get_count()-1)
-	return {
-		item=ItemStack(industrialtest.random:next(1,8)==1 and "industrialtest:scrap" or ""),
-		time=2,
-		src=srcAfter
-	}
-end
-
-industrialtest.Recycler:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:recycler",

machines/rotary_macerator.lua

@@ -15,54 +15,67 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.RotaryMacerator=table.copy(industrialtest.ActivatedElectricMachine)
-industrialtest.internal.unpackTableInto(industrialtest.RotaryMacerator,{
-	name="industrialtest:rotary_macerator",
-	description=S("Rotary Macerator"),
-	tiles={
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png^industrialtest_macerator_front.png"
-	},
-	sounds="metal",
-	requiresWrench=true,
-	facedir=true,
-	storageLists={
-		"src",
-		"dst",
-		"upgrades",
-		"powerStorage"
-	},
-	powerLists={
-		{
-			list="powerStorage",
-			direction="i"
-		}
-	},
-	active={
-		tiles={
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png^industrialtest_macerator_front_active.png"
-		}
-	},
-	capacity=industrialtest.api.lvPowerFlow*2,
-	flow=industrialtest.api.lvPowerFlow,
-	hasPowerInput=true,
-	ioConfig="iiiiii",
-	_opPower=60,
-	_maintainSpeedOpPower=10
-})
 
-function industrialtest.RotaryMacerator.onConstruct(self,pos)
+local rotaryMacerator={}
+rotaryMacerator.opPower=60
+rotaryMacerator.maintainSpeedOpPower=10
+
+rotaryMacerator.getFormspec=function(pos)
 	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
+	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
+	local maxSrcTime=meta:get_float("maxSrcTime")
+	local srcPercent=maxSrcTime>0 and meta:get_float("srcTime")/maxSrcTime*100 or 0
+	local rpm=meta:get_int("rpm")
+	local buttonMaintainSpeedText=meta:get_int("maintainSpeed")==1 and S("Don't maintain speed") or S("Maintain speed")
+	local formspec
+	if industrialtest.mtgAvailable then
+		formspec={
+			"list[context;src;3.8,1.8;1,1]",
+			"list[context;modifier;4.9,1.8;1,1]",
+			(powerPercent>0 and "image[3.8,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
+			 or "image[3.8,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
+			"list[context;powerStorage;3.8,3.9;1,1]",
+			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
+			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
+			"list[context;dst;6,2.8;1,1;]",
+			"list[context;upgrades;9,0.9;1,4]",
+			"label[0.5,2.8;"..minetest.formspec_escape(S("Speed: @1",rpm)).."]",
+			"button[0.5,3.4;3,0.8;maintainSpeed;"..minetest.formspec_escape(buttonMaintainSpeedText).."]",
+			"listring[context;src]",
+			"listring[context;modifier]",
+			"listring[context;powerStorage]",
+			"listring[context;dst]",
+			"listring[context;upgrades]"
+		}
+	elseif industrialtest.mclAvailable then
+		formspec={
+			"list[context;src;3.8,1.8;1,1]",
+			mcl_formspec.get_itemslot_bg(3.8,1.8,1,1),
+			"list[context;modifier;4.9,1.8;1,1]",
+			mcl_formspec.get_itemslot_bg(4.9,1.8,1,1),
+			(powerPercent>0 and "image[3.8,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
+			 or "image[3.8,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
+			"list[context;powerStorage;3.8,3.9;1,1]",
+			mcl_formspec.get_itemslot_bg(3.8,3.9,1,1),
+			(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
+			 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
+			"list[context;dst;6,2.8;1,1;]",
+			mcl_formspec.get_itemslot_bg(6,2.8,1,1),
+			"list[context;upgrades;9,0.9;1,4]",
+			mcl_formspec.get_itemslot_bg(9,0.9,1,4),
+			"label[0.5,2.8;"..minetest.formspec_escape(S("Speed: @1",rpm)).."]",
+			"button[0.5,3.4;3,0.8;maintainSpeed;"..minetest.formspec_escape(buttonMaintainSpeedText).."]",
+			"listring[context;src]",
+			"listring[context;modifier]",
+			"listring[context;powerStorage]",
+			"listring[context;dst]",
+			"listring[context;upgrades]"
+		}
+	end
+	return table.concat(formspec,"")
+end
+
+rotaryMacerator.onConstruct=function(pos,meta,inv)
 	inv:set_size("src",1)
 	inv:set_size("modifier",1)
 	inv:set_size("powerStorage",1)
@@ -72,176 +85,140 @@ function industrialtest.RotaryMacerator.onConstruct(self,pos)
 	meta:set_float("srcTime",0)
 	meta:set_float("maxSrcTime",0)
 	meta:set_int("maintainSpeed",0)
-	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
 end
 
-function industrialtest.RotaryMacerator.getFormspec(self,pos)
+rotaryMacerator.onTimer=function(pos,elapsed,meta,inv)
-	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
-	local meta=minetest.get_meta(pos)
-	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
-	local maxSrcTime=meta:get_float("maxSrcTime")
-	local srcPercent=maxSrcTime>0 and meta:get_float("srcTime")/maxSrcTime*100 or 0
-	local rpm=meta:get_int("rpm")
-	local buttonMaintainSpeedText=meta:get_int("maintainSpeed")==1 and S("Don't maintain speed") or S("Maintain speed")
-	local formspec={
-		"list[context;src;3.8,1.8;1,1]",
-		industrialtest.internal.getItemSlotBg(3.8,1.8,1,1),
-		"list[context;modifier;4.9,1.8;1,1]",
-		industrialtest.internal.getItemSlotBg(4.9,1.8,1,1),
-		(powerPercent>0 and "image[3.8,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
-		 or "image[3.8,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
-		"list[context;powerStorage;3.8,3.9;1,1]",
-		industrialtest.internal.getItemSlotBg(3.8,3.9,1,1),
-		(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
-		 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
-		"list[context;dst;6,2.8;1,1;]",
-		industrialtest.internal.getItemSlotBg(6,2.8,1,1),
-		"list[context;upgrades;9,0.9;1,4]",
-		industrialtest.internal.getItemSlotBg(9,0.9,1,4),
-		"label[0.5,2.8;"..minetest.formspec_escape(S("Speed: @1",rpm)).."]",
-		"button[0.5,3.4;3,0.8;maintainSpeed;"..minetest.formspec_escape(buttonMaintainSpeedText).."]",
-		"listring[context;src]",
-		"listring[context;dst]"
-	}
-	return parentFormspec..table.concat(formspec,"")
-end
-
-function industrialtest.RotaryMacerator.update(self,pos,elapsed,meta,inv)
 	local shouldRerunTimer=false
 	local shouldUpdateFormspec=false
+	local srcSlot=inv:get_stack("src",1)
+	local modifierSlot=inv:get_stack("modifier",1)
+	local dstSlot=inv:get_stack("dst",1)
 	local rpm=meta:get_int("rpm")
 	local maintainSpeed=meta:get_int("maintainSpeed")
+
+	shouldRerunTimer,shouldUpdateFormspec=industrialtest.internal.chargeFromPowerStorageItem(meta,inv)
 	local powerAmount=meta:get_int("industrialtest.powerAmount")
 
-	if maintainSpeed==1 and powerAmount>=self._maintainSpeedOpPower then
+	if maintainSpeed==1 and powerAmount>=rotaryMacerator.maintainSpeedOpPower then
 		local newRpm=math.max(rpm+10*elapsed,0)
 		if newRpm>rpm then
 			meta:set_int("rpm",newRpm)
 			shouldUpdateFormspec=true
 		end
-		industrialtest.api.addPower(meta,-self._maintainSpeedOpPower)
+		industrialtest.api.addPower(meta,-rotaryMacerator.maintainSpeedOpPower)
 		shouldRerunTimer=true
 	elseif rpm>0 then
 		meta:set_int("rpm",math.max(rpm-1000*elapsed,0))
-		shouldRerunTimer=rpm>0
+		shouldRerunTimer=shouldRerunTimer or rpm>0
 		shouldUpdateFormspec=true
 	end
 
+	if powerAmount>=rotaryMacerator.opPower and not srcSlot:is_empty() then
+		local result=industrialtest.api.getMaceratorRecipeResult(srcSlot:get_name())
+		if result then
+			meta:set_float("srcTime",0)
+			meta:set_float("maxSrcTime",result.time)
+			minetest.swap_node(pos,{
+				name="industrialtest:rotary_macerator_active",
+				param2=minetest.get_node(pos).param2
+			})
+			minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+			return false,shouldUpdateFormspec
+		end
+	end
+	
 	return shouldRerunTimer,shouldUpdateFormspec
 end
 
-function industrialtest.RotaryMacerator.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,count)
+rotaryMacerator.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,count)
 	if toList=="dst" then
 		return 0
 	end
-	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+	return count
 end
 
-function industrialtest.RotaryMacerator.allowMetadataInventoryPut(self,pos,listname,index,stack)
+rotaryMacerator.allowMetadataInventoryPut=function(pos,listname,index,stack)
 	if listname=="dst" then
 		return 0
 	end
-	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack)
+	return stack:get_count()
 end
 
-function industrialtest.RotaryMacerator.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+rotaryMacerator.onMetadataInventoryMove=function(pos)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-	if toList=="src" or toList=="modifier" or fromList=="dst" then
-		self:triggerIfNeeded(pos)
-	end
 end
 
-function industrialtest.RotaryMacerator.onMetadataInventoryPut(self,pos,listname,index,stack,player)
+rotaryMacerator.onMetadataInventoryPut=function(pos)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack,player)
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
-	if listname=="src" or listname=="modifier" then
-		self:triggerIfNeeded(pos)
-	end
 end
 
-function industrialtest.RotaryMacerator.onMetadataInventoryTake(self,pos,listname,index,stack)
+rotaryMacerator.onMetadataInventoryTake=function(pos,listname)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryTake(self,pos,listname,index,stack)
 	if listname=="dst" then
-		self:triggerIfNeeded(pos)
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
 end
 
-function industrialtest.RotaryMacerator.onReceiveFields(self,pos,formname,fields)
+rotaryMacerator.activeOnTimer=function(pos,elapsed,meta,inv)
-	if not fields.maintainSpeed then
-		return
-	end
-	local meta=minetest.get_meta(pos)
-	local maintainSpeed=meta:get_int("maintainSpeed")
-	if maintainSpeed==1 then
-		meta:set_int("maintainSpeed",0)
-	elseif meta:get_int("industrialtest.powerAmount")>=self._maintainSpeedOpPower then
-		meta:set_int("maintainSpeed",1)
-		self:trigger(pos)
-	end
-	self:updateFormspec(pos)
-end
-
-function industrialtest.RotaryMacerator.shouldActivate(self,pos)
-	local meta=minetest.get_meta(pos)
-	local powerAmount=meta:get_int("industrialtest.powerAmount")
-	if powerAmount<self._opPower then
-		return false
-	end
-
-	local inv=meta:get_inventory()
-	local result,_=self.getRecipeResult(pos)
-	if not result or result.time==0 or not inv:room_for_item("dst",ItemStack(result.output)) then
-		return false
-	end
-
-	return true
-end
-
-function industrialtest.RotaryMacerator.shouldDeactivate(self,pos)
-	return not self:shouldActivate(pos)
-end
-
-function industrialtest.RotaryMacerator.afterDeactivation(self,pos)
-	local meta=minetest.get_meta(pos)
-	meta:set_float("srcTime",0)
-	meta:set_float("maxSrcTime",0)
-end
-
-function industrialtest.RotaryMacerator.activeUpdate(self,pos,elapsed,meta,inv)
 	local srcSlot=inv:get_stack("src",1)
+	local modifierSlot=inv:get_stack("modifier",1)
 	local dstSlot=inv:get_stack("dst",1)
 	local powerAmount=meta:get_int("industrialtest.powerAmount")
 	local rpm=meta:get_int("rpm")
-	local maxSrcTime=meta:get_float("maxSrcTime")
 	local speed=industrialtest.api.getMachineSpeed(meta)
-	local requiredPower=elapsed*self._opPower*speed
+	local requiredPower=elapsed*rotaryMacerator.opPower*speed
 
-	if maxSrcTime<=0 then
+	industrialtest.internal.chargeFromPowerStorageItem(meta,inv)
-		local result,_=self.getRecipeResult(pos)
+
-		meta:set_float("maxSrcTime",result.time)
+	if srcSlot:is_empty() or powerAmount<requiredPower then
-		maxSrcTime=result.time
+		meta:set_float("srcTime",0)
+		meta:set_float("maxSrcTime",0)
+		minetest.swap_node(pos,{
+			name="industrialtest:rotary_macerator",
+			param2=minetest.get_node(pos).param2
+		})
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		return false,true
 	end
 
-	local srcTime=meta:get_float("srcTime")+elapsed*(1+rpm/7500)
+	local result
-	if srcTime>=maxSrcTime then
+	local modified=false
-		local result,modified=self.getRecipeResult(pos)
+	if not modifierSlot:is_empty() then
+		result=industrialtest.api.getRotaryMaceratorModifier(srcSlot:get_name(),modifierSlot:get_name())
+	end
+	if result then
+		modified=true
+	else
+		result=industrialtest.api.getMaceratorRecipeResult(srcSlot:get_name())
+	end
 	local resultStack=ItemStack(result.output)
+	if not dstSlot:item_fits(resultStack) then
+		meta:set_float("srcTime",0)
+		meta:set_float("maxSrcTime",0)
+		minetest.swap_node(pos,{
+			name="industrialtest:rotary_macerator",
+			param2=minetest.get_node(pos).param2
+		})
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+		return false,true
+	end
+	meta:set_float("maxSrcTime",result.time)
+
+	local srcTime=meta:get_float("srcTime")+elapsed*(1+rpm/7500)
+	if srcTime>=meta:get_float("maxSrcTime") then
 		local multiplier=math.min(srcSlot:get_count(),speed)
 		local prevCount=resultStack:get_count()
 		resultStack:set_count(resultStack:get_count()*multiplier)
 		local leftover=inv:add_item("dst",resultStack)
 		meta:set_float("srcTime",0)
+		meta:set_float("maxSrcTime",0)
 		srcSlot:take_item(multiplier-leftover:get_count()/prevCount)
 		inv:set_stack("src",1,srcSlot)
 		meta:set_int("rpm",math.min(rpm+750*elapsed,7500))
 		if modified then
-			local modifierSlot=inv:get_stack("modifier",1)
 			local modifierMeta=modifierSlot:get_meta()
 			local uses=result.uses
-			local replace=false
 			if modifierMeta:contains("uses") then
 				uses=modifierMeta:get_int("uses")
-			else
-				replace=true
 			end
 			uses=math.max(uses-1,0)
 			if uses==0 then
@@ -253,12 +230,7 @@ function industrialtest.RotaryMacerator.activeUpdate(self,pos,elapsed,meta,inv)
 				uses=result.uses
 			end
 			if not modifierSlot:is_empty() and not result.modifierLeftover then
-				local modifierDef=modifierSlot:get_definition()
 				modifierMeta:set_int("uses",uses)
-				modifierMeta:set_string("description",string.format("%s (%s: %d)",modifierDef.description,S("Uses"),uses))
-			end
-			if replace then
-				modifierSlot:set_name(result.stackLeftover)
 			end
 			inv:set_stack("modifier",1,modifierSlot)
 		end
@@ -268,29 +240,55 @@ function industrialtest.RotaryMacerator.activeUpdate(self,pos,elapsed,meta,inv)
 
 	industrialtest.api.addPower(meta,-requiredPower)
 
-	return true
+	return true,true
-end
-
-industrialtest.RotaryMacerator:register()
-
-function industrialtest.RotaryMacerator.getRecipeResult(pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local srcSlot=inv:get_stack("src",1)
-	local modifierSlot=inv:get_stack("modifier",1)
-
-	local result
-	local modified=false
-	if modifierSlot:is_empty() then
-		result=industrialtest.api.getMaceratorRecipeResult(srcSlot:get_name())
-	else
-		result=industrialtest.api.getRotaryMaceratorModifier(srcSlot:get_name(),modifierSlot:get_name())
-		modified=true
-	end
-
-	return result,modified
 end
 
+industrialtest.internal.registerMachine({
+	name="rotary_macerator",
+	displayName=S("Rotary Macerator"),
+	capacity=industrialtest.api.lvPowerFlow*2,
+	getFormspec=rotaryMacerator.getFormspec,
+	flow=industrialtest.api.lvPowerFlow,
+	ioConfig="iiiiii",
+	requiresWrench=true,
+	registerActiveVariant=true,
+	sounds="metal",
+	powerSlots={"powerStorage"},
+	storageSlots={"src","modifier","powerStorage","dst","upgrades"},
+	groups={
+		_industrialtest_hasPowerInput=1
+	},
+	customKeys={
+		tiles={
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png^industrialtest_macerator_front.png"
+		},
+		paramtype2="facedir",
+		legacy_facedir_simple=true
+	},
+	activeCustomKeys={
+		tiles={
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png^industrialtest_macerator_front_active.png"
+		}
+	},
+	onConstruct=rotaryMacerator.onConstruct,
+	onTimer=rotaryMacerator.onTimer,
+	allowMetadataInventoryMove=rotaryMacerator.allowMetadataInventoryMove,
+	allowMetadataInventoryPut=rotaryMacerator.allowMetadataInventoryPut,
+	onMetadataInventoryPut=rotaryMacerator.onMetadataInventoryPut,
+	onMetadataInventoryMove=rotaryMacerator.onMetadataInventoryMove,
+	onMetadataInventoryTake=rotaryMacerator.onMetadataInventoryTake,
+	activeOnTimer=rotaryMacerator.activeOnTimer
+})
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:rotary_macerator",

machines/simple_electric_item_processor.lua

@@ -1,220 +0,0 @@
--- IndustrialTest
--- Copyright (C) 2025 mrkubax10
-
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
-
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
-
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-industrialtest.SimpleElectricItemProcessor=table.copy(industrialtest.ActivatedElectricMachine)
-industrialtest.internal.unpackTableInto(industrialtest.SimpleElectricItemProcessor,{
-	facedir=true,
-	sounds="metal",
-	storageLists={
-		"src",
-		"dst",
-		"powerStorage",
-		"upgrades"
-	},
-	powerLists={
-		{
-			list="powerStorage",
-			direction="i"
-		}
-	},
-	hasPowerInput=true,
-	ioConfig="iiiiii"
-})
-
-function industrialtest.SimpleElectricItemProcessor.onConstruct(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	inv:set_size("src",1)
-	inv:set_size("dst",1)
-	inv:set_size("powerStorage",1)
-	inv:set_size("upgrades",4)
-	meta:set_float("srcTime",-1)
-	meta:set_float("maxSrcTime",0)
-	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
-end
-
-function industrialtest.SimpleElectricItemProcessor.getFormspec(self,pos)
-	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
-	local meta=minetest.get_meta(pos)
-	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
-	local srcPercent=meta:get_float("srcTime")/meta:get_float("maxSrcTime")*100
-	local formspec={
-		"list[context;src;3.4,1.8;1,1]",
-		industrialtest.internal.getItemSlotBg(3.4,1.8,1,1),
-		(powerPercent>0 and "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
-		 or "image[3.4,2.8;1,1;industrialtest_gui_electricity_bg.png]"),
-		"list[context;powerStorage;3.4,3.9;1,1]",
-		industrialtest.internal.getItemSlotBg(3.4,3.9,1,1),
-		(srcPercent>0 and "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[lowpart:"..srcPercent..":gui_furnace_arrow_fg.png^[transformR270]"
-		 or "image[4.9,2.8;1,1;gui_furnace_arrow_bg.png^[transformR270]"),
-		"list[context;dst;6.4,2.8;1,1]",
-		industrialtest.internal.getItemSlotBg(6.4,2.8,1,1),
-		"list[context;upgrades;9,0.9;1,4]",
-		industrialtest.internal.getItemSlotBg(9,0.9,1,4),
-		"listring[context;src]",
-		"listring[context;dst]"
-	}
-	return parentFormspec..table.concat(formspec,"")
-end
-
-function industrialtest.SimpleElectricItemProcessor.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,count)
-	if toList=="dst" then
-		return 0
-	end
-	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,count)
-end
-
-function industrialtest.SimpleElectricItemProcessor.allowMetadataInventoryPut(self,pos,listname,index,stack)
-	if listname=="dst" then
-		return 0
-	elseif listname=="src" then
-		local meta=minetest.get_meta(pos)
-		local inv=meta:get_inventory()
-		local srcSlot=inv:get_stack("src",1)
-		if srcSlot:get_name()~=stack:get_name() then
-			meta:set_float("srcTime",-1)
-			meta:set_float("maxSrcTime",0)
-		end
-	end
-	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack)
-end
-
-function industrialtest.SimpleElectricItemProcessor.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local srcSlot=inv:get_stack("src",1)
-	local dstSlot=inv:get_stack("dst",1)
-	if fromList=="src" and srcSlot:is_empty() then
-		meta:set_float("srcTime",-1)
-		meta:set_float("maxSrcTime",0)
-		self:updateFormspec(pos)
-	elseif fromList=="dst" and dstSlot:get_free_space()>0 then
-		self:triggerIfNeeded(pos)
-	end
-end
-
-function industrialtest.SimpleElectricItemProcessor.onMetadataInventoryPut(self,pos,listname,index,stack)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
-	self:triggerIfNeeded(pos)
-end
-
-function industrialtest.SimpleElectricItemProcessor.onMetadataInventoryTake(self,pos,listname,index,stack)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryTake(self,pos,listname,index,stack)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	local srcSlot=inv:get_stack("src",1)
-	local dstSlot=inv:get_stack("dst",1)
-	if listname=="src" and srcSlot:is_empty() then
-		meta:set_float("srcTime",-1)
-		meta:set_float("maxSrcTime",0)
-		self:updateFormspec(pos)
-	elseif listname=="dst" and dstSlot:get_free_space()>0 then
-		self:triggerIfNeeded(pos)
-	end
-end
-
-function industrialtest.SimpleElectricItemProcessor.register(self)
-	industrialtest.ActivatedElectricMachine.register(self)
-	industrialtest.api.addTag(self.name,"simpleElectricItemProcessor")
-end
-
-function industrialtest.SimpleElectricItemProcessor.shouldActivate(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-
-	if meta:get_float("maxSrcTime")>0 and meta:get_float("srcTime")>=0 then
-		return false
-	end
-
-	-- TODO: Take elapsed time into account
-	local requiredPower=self.opPower*industrialtest.api.getMachineSpeed(meta)
-	if meta:get_int("industrialtest.powerAmount")<requiredPower then
-		return false
-	end
-
-	local srcSlot=inv:get_stack("src",1)
-	if srcSlot:get_count()>0 then
-		local output=self:getCraftResult(srcSlot)
-		return output and output.time>0 and inv:room_for_item("dst",output.item)
-	end
-	return false
-end
-
-function industrialtest.SimpleElectricItemProcessor.shouldDeactivate(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-
-	-- TODO: Take elapsed time into account
-	local requiredPower=self.opPower*industrialtest.api.getMachineSpeed(meta)
-	if meta:get_int("industrialtest.powerAmount")<requiredPower then
-		return true
-	end
-
-	local srcSlot=inv:get_stack("src",1)
-	if srcSlot:is_empty() then
-		return true
-	end
-
-	local output=self:getCraftResult(srcSlot)
-	return not output or output.time==0 or not inv:room_for_item("dst",output.item)
-end
-
-function industrialtest.SimpleElectricItemProcessor.activeUpdate(self,pos,elapsed,meta,inv)
-	local srcSlot=inv:get_stack("src",1)
-
-	local srcTime=0
-	local maxSrcTime
-	if meta:get_float("maxSrcTime")<=0 then
-		local output=self:getCraftResult(srcSlot)
-		maxSrcTime=output.time*self.efficiency
-		meta:set_float("srcTime",0)
-		meta:set_float("maxSrcTime",maxSrcTime)
-		shouldUpdateFormspec=true
-	else
-		srcTime=meta:get_float("srcTime")
-		maxSrcTime=meta:get_float("maxSrcTime")
-	end
-
-	local speed=industrialtest.api.getMachineSpeed(meta)
-	local requiredPower=elapsed*self.opPower*speed
-	industrialtest.api.addPower(meta,-requiredPower)
-	srcTime=srcTime+elapsed
-	meta:set_int("srcTime",srcTime)
-
-	if srcTime>=maxSrcTime then
-		local output=self:getCraftResult(srcSlot)
-		local usedItems=srcSlot:get_count()-output.src:get_count()
-		local multiplier=1
-		if srcSlot:get_count()>=speed*usedItems then
-			multiplier=speed
-		end
-		if output.item:get_count()>0 then
-			output.item:set_count(output.item:get_count()*multiplier)
-			inv:add_item("dst",output.item)
-		end
-		meta:set_float("srcTime",-1)
-		meta:set_float("maxSrcTime",0)
-		srcSlot:set_count(srcSlot:get_count()-multiplier*usedItems)
-		inv:set_stack("src",1,srcSlot)
-	end
-
-	return true
-end
-
-function industrialtest.SimpleElectricItemProcessor.getCraftResult(self,itemstack)
-	-- Dummy method
-end

machines/solar_panel_generator.lua

@@ -15,87 +15,93 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.SolarPanelBase=table.copy(industrialtest.ElectricMachine)
+local solarPanel={}
-industrialtest.internal.unpackTableInto(industrialtest.SolarPanelBase,{
-	sounds="metal",
-	requiresWrench=true,
-	storageLists={
-		"charged"
-	},
-	powerLists={
-		{
-			list="charged",
-			direction="o"
-		}
-	},
-	hasPowerOutput=true,
-	ioConfig="oooooo",
-	multiplier=1
-})
 
-local solarPanels={}
+solarPanel.getFormspec=function(pos)
-
-function industrialtest.SolarPanelBase.onConstruct(self,pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	inv:set_size("charged",1)
-	meta:set_float("prevAmount",0)
-	industrialtest.ElectricMachine.onConstruct(self,pos)
-end
-
-function industrialtest.SolarPanelBase.getFormspec(self,pos)
-	local parentFormspec=industrialtest.ElectricMachine.getFormspec(self,pos)
 	local amount=minetest.get_natural_light(vector.offset(pos,0,1,0))/15.0
 	local charging=amount>0.5
-	local formspec={
+	local formspec
-		"list[context;charged;4.7,1.8;1,1]",
+	if industrialtest.mtgAvailable then
-		industrialtest.internal.getItemSlotBg(4.7,1.8,1,1),
+		formspec={
-		(charging and "image[4.7,2.8;1,1;industrialtest_gui_sun_fg.png]"
+			"list[context;charged;4.9,1.8;1,1]",
-		 or "image[4.7,2.8;1,1;industrialtest_gui_sun_bg.png]"),
+			"listring[context;charged]",
-		"listring[context;charged]"
+			(charging and "image[4.9,2.8;1,1;industrialtest_gui_sun_fg.png]"
+			 or "image[4.9,2.8;1,1;industrialtest_gui_sun_bg.png]")
 		}
-	return parentFormspec..table.concat(formspec,"")
+	elseif industrialtest.mclAvailable then
+		formspec={
+			"list[context;charged;4.7,1.8;1,1]",
+			mcl_formspec.get_itemslot_bg(4.7,1.8,1,1),
+			"listring[context;charged]",
+			(charging and "image[4.7,2.8;1,1;industrialtest_gui_sun_fg.png]"
+			 or "image[4.7,2.8;1,1;industrialtest_gui_sun_bg.png]")
+		}
+	end
+	return table.concat(formspec,"")
 end
 
-function industrialtest.SolarPanelBase.register(self)
+solarPanel.onConstruct=function(pos,meta,inv)
-	industrialtest.ElectricMachine.register(self)
+	inv:set_size("charged",1)
-	table.insert(solarPanels,self.name)
+	meta:set_float("prevAmount",0)
 end
 
-function industrialtest.SolarPanelBase.action(self,pos)
+solarPanel.onTimer=function(pos,elapsed,meta,inv,config)
-	local meta=minetest.get_meta(pos)
+	local chargedSlot=inv:get_stack("charged",1)
+	local shouldUpdateFormspec=false
 	local amount=minetest.get_natural_light(vector.offset(pos,0,1,0))/15.0
 	local charging=amount>0.5
 	if charging then
-		if industrialtest.api.addPower(meta,math.ceil(amount*self.flow*self.multiplier))>0 then
+		industrialtest.api.addPower(meta,math.ceil(amount*config.flow*elapsed))
-			self:updateFormspec(pos)
 	end
-		self:trigger(pos)
+	if meta:get_int("industrialtest.powerAmount")>0 then
+		if chargedSlot:get_count()>0 and not industrialtest.api.isFullyCharged(chargedSlot:get_meta()) then
+			industrialtest.api.transferPowerToItem(meta,chargedSlot,math.ceil(config.flow*elapsed))
+			inv:set_stack("charged",1,chargedSlot)
+		end
+		industrialtest.api.powerFlow(pos)
 	end
 	if amount~=meta:get_float("prevAmount") then
-		self:updateFormspec(pos)
+		shouldUpdateFormspec=true
 		meta:set_float("prevAmount",amount)
 	end
+	return true,shouldUpdateFormspec
 end
 
-industrialtest.SolarPanel=table.copy(industrialtest.SolarPanelBase)
+local function registerSolarPanelGenerator(config)
-industrialtest.internal.unpackTableInto(industrialtest.SolarPanel,{
+	industrialtest.internal.registerMachine({
-	name="industrialtest:solar_panel",
+		name=config.name,
-	description=S("Solar Panel"),
+		displayName=config.displayName,
-	tiles={
+		getFormspec=solarPanel.getFormspec,
-		"industrialtest_machine_block.png^industrialtest_solar_panel_top.png",
+		capacity=config.capacity,
-		"industrialtest_machine_block.png",
+		flow=config.flow,
-		"industrialtest_machine_block.png",
+		ioConfig="oooooo",
-		"industrialtest_machine_block.png",
+		requiresWrench=true,
-		"industrialtest_machine_block.png",
+		registerActiveVariant=false,
-		"industrialtest_machine_block.png"
+		powerSlots={"charged"},
+		storageSlots={"charged"},
+		sounds="metal",
+		groups={
+			_industrialtest_hasPowerOutput=1
 		},
+		customKeys={
+			tiles={
+				"industrialtest_machine_block.png^industrialtest_"..config.name.."_top.png",
+				"industrialtest_machine_block.png"
+			}
+		},
+		onConstruct=solarPanel.onConstruct,
+		onTimer=function(pos,elapsed,meta,inv)
+			return solarPanel.onTimer(pos,elapsed,meta,inv,config)
+		end
+	})
+end
+
+registerSolarPanelGenerator({
+	name="solar_panel",
+	displayName=S("Solar Panel"),
 	capacity=industrialtest.api.lvPowerFlow*2,
 	flow=industrialtest.api.lvPowerFlow
 })
-
-industrialtest.SolarPanel:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:solar_panel",
@@ -106,25 +112,12 @@ minetest.register_craft({
 	}
 })
 
-industrialtest.LVSolarArray=table.copy(industrialtest.SolarPanelBase)
+registerSolarPanelGenerator({
-industrialtest.internal.unpackTableInto(industrialtest.LVSolarArray,{
+	name="lv_solar_array",
-	name="industrialtest:lv_solar_array",
+	displayName=S("LV Solar Array"),
-	description=S("LV Solar Array"),
-	tiles={
-		"industrialtest_machine_block.png^industrialtest_lv_solar_array_top.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png"
-	},
 	capacity=industrialtest.api.lvPowerFlow*4,
-	flow=industrialtest.api.lvPowerFlow,
+	flow=industrialtest.api.lvPowerFlow*2
-	multiplier=1.5
 })
-
-industrialtest.LVSolarArray:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:lv_solar_array",
@@ -135,24 +128,12 @@ minetest.register_craft({
 	}
 })
 
-industrialtest.MVSolarArray=table.copy(industrialtest.SolarPanelBase)
+registerSolarPanelGenerator({
-industrialtest.internal.unpackTableInto(industrialtest.MVSolarArray,{
+	name="mv_solar_array",
-	name="industrialtest:mv_solar_array",
+	displayName=S("MV Solar Array"),
-	description=S("MV Solar Array"),
-	tiles={
-		"industrialtest_machine_block.png^industrialtest_mv_solar_array_top.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png"
-	},
 	capacity=industrialtest.api.mvPowerFlow*2,
 	flow=industrialtest.api.mvPowerFlow
 })
-
-industrialtest.MVSolarArray:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:mv_solar_array",
@@ -163,25 +144,12 @@ minetest.register_craft({
 	}
 })
 
-
+registerSolarPanelGenerator({
-industrialtest.HVSolarArray=table.copy(industrialtest.SolarPanelBase)
+	name="hv_solar_array",
-industrialtest.internal.unpackTableInto(industrialtest.HVSolarArray,{
+	displayName=S("HV Solar Array"),
-	name="industrialtest:hv_solar_array",
-	description=S("HV Solar Array"),
-	tiles={
-		"industrialtest_machine_block.png^industrialtest_hv_solar_array_top.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png"
-	},
 	capacity=industrialtest.api.hvPowerFlow*2,
 	flow=industrialtest.api.hvPowerFlow
 })
-
-industrialtest.HVSolarArray:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:hv_solar_array",
@@ -191,14 +159,3 @@ minetest.register_craft({
 		{"industrialtest:mv_solar_array","industrialtest:mv_solar_array","industrialtest:mv_solar_array"}
 	}
 })
-
-minetest.register_abm({
-	name="Solar panel updating",
-	nodenames=solarPanels,
-	interval=industrialtest.config.updateDelay,
-	chance=1,
-	action=function(pos,node)
-		local def=minetest.registered_nodes[node.name]
-		def._industrialtest_self:action(pos)
-	end
-})

machines/tool_workshop.lua

@@ -15,137 +15,111 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.ToolWorkshop=table.copy(industrialtest.ActivatedElectricMachine)
+local toolWorkshop={}
-industrialtest.internal.unpackTableInto(industrialtest.ToolWorkshop,{
-	name="industrialtest:tool_workshop",
-	description=S("Tool Workshop"),
-	tiles={
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png",
-		"industrialtest_advanced_machine_block.png^industrialtest_tool_workshop_front.png",
-	},
-	sounds="metal",
-	requiresWrench=true,
-	facedir=true,
-	storageLists={
-		"src",
-		"upgrades",
-		"powerStorage"
-	},
-	powerLists={
-		{
-			list="powerStorage",
-			direction="i"
-		}
-	},
-	active={
-		tiles={
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png",
-			"industrialtest_advanced_machine_block.png^industrialtest_tool_workshop_front_active.png",
-		}
-	},
-	capacity=15000,
-	flow=industrialtest.api.hvPowerFlow,
-	hasPowerInput=true,
-	ioConfig="iiiiii",
-	_opPower=10000,
-	_efficiency=200
-})
 
-function industrialtest.ToolWorkshop.onConstruct(self,pos)
+toolWorkshop.getFormspec=function(pos)
-	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
-	inv:set_size("powerStorage",1)
-	inv:set_size("src",1)
-	inv:set_size("upgrades",4)
-	industrialtest.ActivatedElectricMachine.onConstruct(self,pos)
-end
-
-function industrialtest.ToolWorkshop.getFormspec(self,pos)
-	local parentFormspec=industrialtest.ActivatedElectricMachine.getFormspec(self,pos)
 	local meta=minetest.get_meta(pos)
 	local powerPercent=meta:get_int("industrialtest.powerAmount")/meta:get_int("industrialtest.powerCapacity")*100
-	local formspec={
+	local formspec
+	if industrialtest.mtgAvailable then
+		formspec={
 			"list[context;powerStorage;3.7,3.7;1,1;0]",
-		industrialtest.internal.getItemSlotBg(3.7,3.7,1,1),
+			"listring[context;powerStorage]",
 			(powerPercent>0 and "image[3.7,2.5;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
 			 or "image[3.7,2.5;1,1;industrialtest_gui_electricity_bg.png]"),
-		"list[context;src;5.9,3.2;1,1;0]",
+			"list[context;tool;5.9,3.2;1,1;0]",
-		industrialtest.internal.getItemSlotBg(5.9,3.2,1,1),
+			"listring[context;tool]",
 			"list[context;upgrades;9,0.9;1,4]",
-		industrialtest.internal.getItemSlotBg(9,0.9,1,4),
+			"listring[context;upgrades]"
-		"listring[context;src]"
 		}
-	return parentFormspec..table.concat(formspec,"")
+	elseif industrialtest.mclAvailable then
+		formspec={
+			"list[context;powerStorage;3.7,3.7;1,1;0]",
+			mcl_formspec.get_itemslot_bg(3.7,3.7,1,1),
+			"listring[context;powerStorage]",
+			(powerPercent>0 and "image[3.7,2.5;1,1;industrialtest_gui_electricity_bg.png^[lowpart:"..powerPercent..":industrialtest_gui_electricity_fg.png]"
+			 or "image[3.7,2.5;1,1;industrialtest_gui_electricity_bg.png]"),
+			"list[context;tool;5.9,3.2;1,1;0]",
+			mcl_formspec.get_itemslot_bg(5.9,3.2,1,1),
+			"listring[context;tool]",
+			"list[context;upgrades;9,0.9;1,4]",
+			mcl_formspec.get_itemslot_bg(9,0.9,1,4),
+			"listring[context;upgrades]"
+		}
+	end
+	return table.concat(formspec,"")
 end
 
-function industrialtest.ToolWorkshop.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+toolWorkshop.onConstruct=function(pos,meta,inv)
-	if toList=="src" then
+	inv:set_size("powerStorage",1)
-		local meta=minetest.get_meta(pos)
+	inv:set_size("tool",1)
-		local inv=meta:get_inventory()
+	inv:set_size("upgrades",4)
-		local movedItemStack=inv:get_stack(fromList,fromIndex)
-		if not self.isTool(movedItemStack) then
-			return 0
-		end
-	end
-	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
 end
 
-function industrialtest.ToolWorkshop.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
+toolWorkshop.onTimer=function(pos,elapsed,meta,inv)
-	if listname=="tool" and not self.isTool(stack) then
+	local powerStorageSlot=inv:get_stack("powerStorage",1)
-		return 0
+	local toolSlot=inv:get_stack("tool",1)
+	local requiredPower=industrialtest.api.getMachineSpeed(meta)*10000
+	local shouldRerunTimer=false
+	local shouldUpdateFormspec=false
+
+	if powerStorageSlot:get_count()>0 then
+		local stackMeta=powerStorageSlot:get_meta()
+		if industrialtest.api.transferPower(stackMeta,meta,stackMeta:get_int("industrialtest.powerFlow"))>0 then
+			shouldUpdateFormspec=true
+			shouldRerunTimer=true
+			industrialtest.api.updateItemPowerText(powerStorageSlot)
+			inv:set_stack("powerStorage",1,powerStorageSlot)
 		end
-	return industrialtest.ActivatedElectricMachine.allowMetadataInventoryPut(self,pos,listname,index,stack,player)
 	end
 
-function industrialtest.ToolWorkshop.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+	if toolSlot:get_count()>0 and toolSlot:get_wear()>0 and meta:get_int("industrialtest.powerAmount")>=requiredPower then
-	self:triggerIfNeeded(pos)
+		minetest.swap_node(pos,{
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryMove(self,pos,fromList,fromIndex,toList,toIndex,count)
+			name="industrialtest:tool_workshop_active",
+			param2=minetest.get_node(pos).param2
+		})
+		minetest.get_node_timer(pos):start(industrialtest.updateDelay)
 	end
 
-function industrialtest.ToolWorkshop.onMetadataInventoryPut(self,pos,listname,index,stack)
+	return shouldRerunTimer,shouldUpdateFormspec
-	self:triggerIfNeeded(pos)
-	industrialtest.ActivatedElectricMachine.onMetadataInventoryPut(self,pos,listname,index,stack)
 end
 
-function industrialtest.ToolWorkshop.shouldActivate(self,pos)
+toolWorkshop.activeOnTimer=function(pos,elapsed,meta,inv)
-	local meta=minetest.get_meta(pos)
+	local powerStorageSlot=inv:get_stack("powerStorage",1)
-
+	local toolSlot=inv:get_stack("tool",1)
-	local requiredPower=industrialtest.api.getMachineSpeed(meta)*self._opPower
-	if meta:get_int("industrialtest.powerAmount")<requiredPower then
-		return false
-	end
-
-	local inv=meta:get_inventory()
-	local toolSlot=inv:get_stack("src",1)
-	return not toolSlot:is_empty() and self.isTool(toolSlot) and toolSlot:get_wear()>0
-end
-
-function industrialtest.ToolWorkshop.shouldDeactivate(self,pos)
-	return not self:shouldActivate(pos)
-end
-
-function industrialtest.ToolWorkshop.activeUpdate(self,pos,elapsed,meta,inv)
-	local toolSlot=inv:get_stack("src",1)
 	local speed=industrialtest.api.getMachineSpeed(meta)
+	local requiredPower=speed*10000
+	local shouldRerunTimer=false
+	local shouldUpdateFormspec=false
 
-	local requiredPower=industrialtest.api.getMachineSpeed(meta)*self._opPower
+	if powerStorageSlot:get_count()>0 then
-	local removed=math.min(toolSlot:get_wear(),speed*self._efficiency)
+		local stackMeta=powerStorageSlot:get_meta()
-	toolSlot:set_wear(toolSlot:get_wear()-removed)
+		if industrialtest.api.transferPower(stackMeta,meta,stackMeta:get_int("industrialtest.powerFlow"))>0 then
-	inv:set_stack("src",1,toolSlot)
+			shouldUpdateFormspec=true
-	industrialtest.api.addPower(meta,-requiredPower)
+			shouldRerunTimer=true
-
+			industrialtest.api.updateItemPowerText(powerStorageSlot)
-	return true
+			inv:set_stack("powerStorage",1,powerStorageSlot)
+		end
 	end
 
-function industrialtest.ToolWorkshop.isTool(stack)
+	if toolSlot:get_count()>0 and toolSlot:get_wear()>0 and meta:get_int("industrialtest.powerAmount")>=requiredPower then
+		local removed=math.min(toolSlot:get_wear(),speed*200)
+		toolSlot:set_wear(toolSlot:get_wear()-removed)
+		inv:set_stack("tool",1,toolSlot)
+		industrialtest.api.addPower(meta,-requiredPower)
+		shouldRerunTimer=true
+		shouldUpdateFormspec=true
+	else
+		minetest.swap_node(pos,{
+			name="industrialtest:tool_workshop",
+			param2=minetest.get_node(pos).param2
+		})
+	end
+
+	return shouldRerunTimer,shouldUpdateFormspec
+end
+
+local function isTool(stack)
 	local def=minetest.registered_tools[stack:get_name()]
 	if not def or industrialtest.api.hasPowerStorage(stack:get_meta())then
 		return false
@@ -153,8 +127,76 @@ function industrialtest.ToolWorkshop.isTool(stack)
 	return def.groups and (def.groups.pickaxe or def.groups.sword or def.groups.hoe or def.groups.tool or def.groups.weapon or def.groups.shovel or def.groups.axe)
 end
 
-industrialtest.ToolWorkshop:register()
+toolWorkshop.allowMetadataInventoryMove=function(pos,fromList,fromIndex,toList,toIndex,count)
+	if toList=="tool" then
+		local meta=minetest.get_meta(pos)
+		local inv=meta:get_inventory()
+		local movedItemStack=inv:get_stack(fromList,fromIndex)
+		if not isTool(movedItemStack) then
+			return 0
+		end
+	end
+	return count
+end
 
+toolWorkshop.allowMetadataInventoryPut=function(pos,listname,index,stack)
+	if listname=="tool" and not isTool(stack) then
+		return 0
+	end
+	return stack:get_count()
+end
+
+toolWorkshop.metadataChange=function(pos)
+	minetest.get_node_timer(pos):start(industrialtest.updateDelay)
+end
+
+industrialtest.internal.registerMachine({
+	name="tool_workshop",
+	displayName=S("Tool Workshop"),
+	getFormspec=toolWorkshop.getFormspec,
+	capacity=20000,
+	flow=industrialtest.api.hvPowerFlow,
+	ioConfig="iiiiii",
+	requiresWrench=true,
+	registerActiveVariant=true,
+	powerSlots={"powerStorage"},
+	storageSlots={"tool"},
+	sounds="metal",
+	groups={
+		_industrialtest_hasPowerInput=1
+	},
+	customKeys={
+		tiles={
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png^industrialtest_tool_workshop_front.png",
+			"industrialtest_advanced_machine_block.png"
+		},
+		paramtype2="facedir",
+		legacy_facedir_simple=true
+	},
+	activeCustomKeys={
+		tiles={
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png",
+			"industrialtest_advanced_machine_block.png^industrialtest_tool_workshop_front_active.png",
+			"industrialtest_advanced_machine_block.png"
+		},
+	},
+	onConstruct=toolWorkshop.onConstruct,
+	onTimer=toolWorkshop.onTimer,
+	activeOnTimer=toolWorkshop.activeOnTimer,
+	allowMetadataInventoryMove=toolWorkshop.allowMetadataInventoryMove,
+	allowMetadataInventoryPut=toolWorkshop.allowMetadataInventoryPut,
+	onMetadataInventoryPut=toolWorkshop.metadataChange,
+	onMetadataInventoryMove=toolWorkshop.metadataChange
+})
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:tool_workshop",

machines/transformer.lua

@@ -15,70 +15,81 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.Transformer=table.copy(industrialtest.ElectricMachine)
+local transformer={}
-industrialtest.internal.unpackTableInto(industrialtest.Transformer,{
-	withoutFormspec=true,
-	facedir=true,
-	storageLists={},
-	powerLists={},
-	hasPowerInput=true,
-	hasPowerOutput=true
-})
 
-function industrialtest.Transformer.register(self)
+transformer.onPowerFlow=function(pos,side,amount)
-	self.ioConfig={
+	local normalized=industrialtest.api.normalizeSide(pos,side)
-		{
+	local def=minetest.registered_nodes[minetest.get_node(pos).name]
-			mode="a",
+	if normalized~=5 and amount>=def._industrialtest_lowerFlow then
-			flow=self.lowerFlow
+		minetest.remove_node(pos)
-		},
+		industrialtest.internal.explode(pos,2)
-		{
+	end
-			mode="a",
-			flow=self.lowerFlow
-		},
-		{
-			mode="a",
-			flow=self.lowerFlow
-		},
-		{
-			mode="a",
-			flow=self.lowerFlow
-		},
-		{
-			mode="a",
-			flow=self.flow
-		},
-		{
-			mode="a",
-			flow=self.lowerFlow
-		}
-	}
-	industrialtest.ElectricMachine.register(self)
 end
 
-function industrialtest.Transformer.onPowerFlow(self,pos)
+transformer.onTimer=function(pos,elapsed,meta)
-	self:trigger(pos)
+	local powerAmount=meta:get_int("industrialtest.powerAmount")
+	local def=minetest.registered_nodes[minetest.get_node(pos).name]
+	local afterFlowLower=false
+	local afterFlowUpper=false
+	if powerAmount>=def._industrialtest_lowerFlow then
+		afterFlowLower,_=industrialtest.api.powerFlow(pos,{
+			[1]=true,
+			[2]=true,
+			[3]=true,
+			[4]=true,
+			[6]=true
+		},def._industrialtest_lowerFlow)
+	end
+	if powerAmount>=def._industrialtest_upperFlow then
+		afterFlowUpper,_=industrialtest.api.powerFlow(pos,{[5]=true},def._industrialtest_upperFlow)
+	end
+	return powerAmount>0 and (afterFlowLower or afterFlowUpper),false
 end
 
-industrialtest.LVTransformer=table.copy(industrialtest.Transformer)
+local function registerTransformer(config)
-industrialtest.internal.unpackTableInto(industrialtest.LVTransformer,{
+	industrialtest.internal.registerMachine({
-	name="industrialtest:lv_transformer",
+		name=config.name,
-	description=S("LV Transformer"),
+		displayName=config.displayName,
-	sounds="wood",
+		capacity=industrialtest.api.ivPowerFlow,
+		flow=industrialtest.api.ivPowerFlow,
+		ioConfig="aaaaaa",
+		storageSlots={},
+		powerSlots={},
+		sounds=config.sounds,
+		groups={
+			_industrialtest_hasPowerOutput=1,
+			_industrialtest_hasPowerInput=1,
+		},
+		customKeys={
 			tiles={
-		"industrialtest_wood_machine_block.png^industrialtest_lv_transformer_side.png",
+				config.machineBlockTexture.."^industrialtest_"..config.name.."_side.png",
-		"industrialtest_wood_machine_block.png^industrialtest_lv_transformer_side.png",
+				config.machineBlockTexture.."^industrialtest_"..config.name.."_side.png",
-		"industrialtest_wood_machine_block.png^industrialtest_lv_transformer_side.png",
+				config.machineBlockTexture.."^industrialtest_"..config.name.."_side.png",
-		"industrialtest_wood_machine_block.png^industrialtest_lv_transformer_side.png",
+				config.machineBlockTexture.."^industrialtest_"..config.name.."_side.png",
-		"industrialtest_wood_machine_block.png^industrialtest_lv_transformer_side.png",
+				config.machineBlockTexture.."^industrialtest_"..config.name.."_side.png",
-		"industrialtest_wood_machine_block.png^industrialtest_lv_transformer_front.png"
+				config.machineBlockTexture.."^industrialtest_"..config.name.."_front.png"
 			},
-	capacity=industrialtest.api.mvPowerFlow,
+			paramtype2="facedir",
-	flow=industrialtest.api.mvPowerFlow,
+			legacy_facedir_simple=true,
-	lowerFlow=industrialtest.api.lvPowerFlow
+			_industrialtest_lowerFlow=config.lowerFlow,
+			_industrialtest_upperFlow=config.upperFlow,
+			_industrialtest_onPowerFlow=transformer.onPowerFlow
+		},
+		requiresWrench=config.requiresWrench,
+		withoutFormspec=true,
+		onTimer=transformer.onTimer
 	})
+end
 
-industrialtest.LVTransformer:register()
+registerTransformer({
-
+	name="lv_transformer",
+	displayName=S("LV Transformer"),
+	machineBlockTexture="industrialtest_wood_machine_block.png",
+	requiresWrench=false,
+	lowerFlow=industrialtest.api.lvPowerFlow,
+	upperFlow=industrialtest.api.mvPowerFlow,
+	sounds="wood"
+})
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:lv_transformer",
@@ -89,27 +100,15 @@ minetest.register_craft({
 	}
 })
 
-industrialtest.MVTransformer=table.copy(industrialtest.Transformer)
+registerTransformer({
-industrialtest.internal.unpackTableInto(industrialtest.MVTransformer,{
+	name="mv_transformer",
-	name="industrialtest:mv_transformer",
+	displayName=S("MV Transformer"),
-	description=S("MV Transformer"),
+	machineBlockTexture="industrialtest_machine_block.png",
-	sounds="metal",
 	requiresWrench=true,
-	tiles={
+	lowerFlow=industrialtest.api.mvPowerFlow,
-		"industrialtest_machine_block.png^industrialtest_mv_transformer_side.png",
+	upperFlow=industrialtest.api.hvPowerFlow,
-		"industrialtest_machine_block.png^industrialtest_mv_transformer_side.png",
+	sounds="metal"
-		"industrialtest_machine_block.png^industrialtest_mv_transformer_side.png",
-		"industrialtest_machine_block.png^industrialtest_mv_transformer_side.png",
-		"industrialtest_machine_block.png^industrialtest_mv_transformer_side.png",
-		"industrialtest_machine_block.png^industrialtest_mv_transformer_front.png"
-	},
-	capacity=industrialtest.api.hvPowerFlow,
-	flow=industrialtest.api.hvPowerFlow,
-	lowerFlow=industrialtest.api.mvPowerFlow
 })
-
-industrialtest.MVTransformer:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:mv_transformer",
@@ -120,27 +119,15 @@ minetest.register_craft({
 	}
 })
 
-industrialtest.HVTransformer=table.copy(industrialtest.Transformer)
+registerTransformer({
-industrialtest.internal.unpackTableInto(industrialtest.HVTransformer,{
+	name="hv_transformer",
-	name="industrialtest:hv_transformer",
+	displayName=S("HV Transformer"),
-	description=S("HV Transformer"),
+	machineBlockTexture="industrialtest_machine_block.png",
-	sounds="metal",
 	requiresWrench=true,
-	tiles={
+	lowerFlow=industrialtest.api.hvPowerFlow,
-		"industrialtest_machine_block.png^industrialtest_hv_transformer_side.png",
+	upperFlow=industrialtest.api.evPowerFlow,
-		"industrialtest_machine_block.png^industrialtest_hv_transformer_side.png",
+	sounds="metal"
-		"industrialtest_machine_block.png^industrialtest_hv_transformer_side.png",
-		"industrialtest_machine_block.png^industrialtest_hv_transformer_side.png",
-		"industrialtest_machine_block.png^industrialtest_hv_transformer_side.png",
-		"industrialtest_machine_block.png^industrialtest_hv_transformer_front.png"
-	},
-	capacity=industrialtest.api.evPowerFlow,
-	flow=industrialtest.api.evPowerFlow,
-	lowerFlow=industrialtest.api.hvPowerFlow
 })
-
-industrialtest.HVTransformer:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:hv_transformer",
@@ -151,27 +138,15 @@ minetest.register_craft({
 	}
 })
 
-industrialtest.EVTransformer=table.copy(industrialtest.Transformer)
+registerTransformer({
-industrialtest.internal.unpackTableInto(industrialtest.EVTransformer,{
+	name="ev_transformer",
-	name="industrialtest:ev_transformer",
+	displayName=S("EV Transformer"),
-	description=S("EV Transformer"),
+	machineBlockTexture="industrialtest_machine_block.png",
-	sounds="metal",
 	requiresWrench=true,
-	tiles={
+	lowerFlow=industrialtest.api.evPowerFlow,
-		"industrialtest_machine_block.png^industrialtest_ev_transformer_side.png",
+	upperFlow=industrialtest.api.ivPowerFlow,
-		"industrialtest_machine_block.png^industrialtest_ev_transformer_side.png",
+	sounds="metal"
-		"industrialtest_machine_block.png^industrialtest_ev_transformer_side.png",
-		"industrialtest_machine_block.png^industrialtest_ev_transformer_side.png",
-		"industrialtest_machine_block.png^industrialtest_ev_transformer_side.png",
-		"industrialtest_machine_block.png^industrialtest_ev_transformer_front.png"
-	},
-	capacity=industrialtest.api.ivPowerFlow,
-	flow=industrialtest.api.ivPowerFlow,
-	lowerFlow=industrialtest.api.evPowerFlow
 })
-
-industrialtest.EVTransformer:register()
-
 minetest.register_craft({
 	type="shaped",
 	output="industrialtest:ev_transformer",

machines/wind_mill.lua

@@ -15,60 +15,40 @@
 -- along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 local S=minetest.get_translator("industrialtest")
-industrialtest.WindMill=table.copy(industrialtest.ElectricMachine)
+local windMill={}
-industrialtest.internal.unpackTableInto(industrialtest.WindMill,{
-	name="industrialtest:wind_mill",
-	description=S("Wind Mill"),
-	tiles={
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png",
-		"industrialtest_machine_block.png^industrialtest_wind_mill_side.png",
-		"industrialtest_machine_block.png^industrialtest_wind_mill_side.png",
-		"industrialtest_machine_block.png^industrialtest_wind_mill_side.png",
-		"industrialtest_machine_block.png^industrialtest_wind_mill_side.png"
-	},
-	sounds="metal",
-	requiresWrench=true,
-	storageLists={
-		"charged"
-	},
-	powerLists={
-		{
-			list="charged",
-			direction="o"
-		}
-	},
-	capacity=7000,
-	flow=industrialtest.api.lvPowerFlow,
-	hasPowerOutput=true,
-	ioConfig="oooooo",
-})
 
-function industrialtest.WindMill.onConstruct(self,pos)
+windMill.getFormspec=function(pos)
 	local meta=minetest.get_meta(pos)
-	local inv=meta:get_inventory()
+	local charging=meta:get_int("charging")
+	local formspec
+	if industrialtest.mtgAvailable then
+		formspec={
+			"list[context;charged;4.9,1.8;1,1]",
+			"listring[context;charged]",
+			(charging>0 and "image[4.9,3;1,1;industrialtest_gui_wind_bg.png^[lowpart:"..charging..":industrialtest_gui_wind_fg.png]"
+			 or "image[4.9,3;1,1;industrialtest_gui_wind_bg.png]")
+		}
+	elseif industrialtest.mclAvailable then
+		formspec={
+			"list[context;charged;4.7,1.8;1,1]",
+			mcl_formspec.get_itemslot_bg(4.7,1.8,1,1),
+			"listring[context;charged]",
+			(charging>0 and "image[4.7,3;1,1;industrialtest_gui_wind_bg.png^[lowpart:"..charging..":industrialtest_gui_wind_fg.png]"
+			 or "image[4.7,3;1,1;industrialtest_gui_wind_bg.png]")
+		}
+	end
+	return table.concat(formspec,"")
+end
+
+windMill.onConstruct=function(pos,meta,inv)
 	inv:set_size("charged",1)
 	meta:set_int("prevCharging",0)
 	meta:set_int("charging",0)
-	industrialtest.ElectricMachine.onConstruct(self,pos)
 end
 
-function industrialtest.WindMill.getFormspec(self,pos)
+windMill.onTimer=function(pos,elapsed,meta,inv)
-	local parentFormspec=industrialtest.ElectricMachine.getFormspec(self,pos)
+	local chargedSlot=inv:get_stack("charged",1)
-	local meta=minetest.get_meta(pos)
+	local shouldUpdateFormspec=false
-	local charging=meta:get_int("charging")
-	local formspec={
-		"list[context;charged;4.7,1.8;1,1]",
-		industrialtest.internal.getItemSlotBg(4.7,1.8,1,1),
-		(charging>0 and "image[4.7,3;1,1;industrialtest_gui_wind_bg.png^[lowpart:"..charging..":industrialtest_gui_wind_fg.png]"
-		 or "image[4.7,3;1,1;industrialtest_gui_wind_bg.png]"),
-		"listring[context;charged]"
-	}
-	return parentFormspec..table.concat(formspec,"")
-end
-
-function industrialtest.WindMill.action(self,pos)
-	local meta=minetest.get_meta(pos)
 	local charging
 	if industrialtest.mtgAvailable then
 		charging=math.min(math.max(pos.y,0)/150,1.0)
@@ -97,17 +77,48 @@ function industrialtest.WindMill.action(self,pos)
 			break
 		end
 	end
-	if industrialtest.api.addPower(meta,math.ceil(charging*industrialtest.api.lvPowerFlow))>0 then
+	industrialtest.api.addPower(meta,math.ceil(charging*elapsed*industrialtest.api.lvPowerFlow))
-		self:trigger(pos)
-	end
 	if meta:get_int("prevCharging")~=charging then
-		meta:set_int("prevCharging",charging)
+		shouldUpdateFormspec=true
-		self:updateFormspec(pos)
 	end
+	if chargedSlot:get_count()>0 and meta:get_int("industrialtest.powerAmount")>0 then
+		if industrialtest.api.transferPowerToItem(meta,chargedSlot,industrialtest.api.lvPowerFlow)>0 then
+			inv:set_stack("charged",1,chargedSlot)
+		end
+	end
+	industrialtest.api.powerFlow(pos)
 	meta:set_int("charging",charging*100)
+	return true,shouldUpdateFormspec
 end
 
-industrialtest.WindMill:register()
+industrialtest.internal.registerMachine({
+	name="wind_mill",
+	displayName=S("Wind Mill"),
+	getFormspec=windMill.getFormspec,
+	capacity=7000,
+	flow=industrialtest.api.lvPowerFlow,
+	ioConfig="oooooo",
+	requiresWrench=true,
+	registerActiveVariant=false,
+	powerSlots={"charged"},
+	storageSlots={"charged"},
+	sounds="metal",
+	groups={
+		_industrialtest_hasPowerOutput=1
+	},
+	customKeys={
+		tiles={
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png",
+			"industrialtest_machine_block.png^industrialtest_wind_mill_side.png",
+			"industrialtest_machine_block.png^industrialtest_wind_mill_side.png",
+			"industrialtest_machine_block.png^industrialtest_wind_mill_side.png",
+			"industrialtest_machine_block.png^industrialtest_wind_mill_side.png"
+		}
+	},
+	onConstruct=windMill.onConstruct,
+	onTimer=windMill.onTimer
+})
 
 minetest.register_craft({
 	type="shaped",
@@ -118,13 +129,3 @@ minetest.register_craft({
 		{"","industrialtest:refined_iron_ingot",""}
 	}
 })
-
-minetest.register_abm({
-	name="Wind mill updating",
-	nodenames={"industrialtest:wind_mill"},
-	interval=industrialtest.config.updateDelay,
-	chance=1,
-	action=function(pos)
-		industrialtest.WindMill:action(pos)
-	end
-})

minerals.lua

@@ -39,7 +39,7 @@ if industrialtest.mtgAvailable then
 		y_min=-31000
 	})
 
-	industrialtest.internal.registerMetal("iridium","Iridium",3)
+	industrialtest.internal.registerMetal("iridium","Iridium",4)
 	minetest.register_ore({
 		ore_type="scatter",
 		ore="industrialtest:stone_with_iridium",

mod.conf

@@ -1,5 +1,5 @@
 name=industrialtest
 description=Adds various machinery
-optional_depends=default,bucket,3d_armor,mcl_core,mcl_copper,mcl_armor,mcl_deepslate,mcl_nether,mcl_buckets,mcl_util,mcl_dye,mcl_rubber,pipeworks,logistica,mesecons
+optional_depends=default,bucket,3d_armor,mcl_core,mcl_copper,mcl_armor,mcl_deepslate,mcl_nether,mcl_buckets,mcl_util,mcl_dye,mcl_rubber,pipeworks,mesecons
 author=IndustrialTest Team
 title=IndustrialTest

nodes.lua

@@ -354,19 +354,6 @@ if not industrialtest.mods.mclRubber then
 					name=="mcl_core:podzol" or name=="mcl_core:podzol_snow" or
 					name=="mcl_core:dirt" or name=="mcl_core:mycelium" or name=="mcl_core:coarse_dirt"
 		end)
-		definition._on_bone_meal=function(itemstack,user,pointed)
-			if industrialtest.random:next(1,100)>45 then
-				return
-			end
-			local meta=minetest.get_meta(pointed.under)
-			local stage=meta:get_int("stage") or 0
-			stage=stage+1
-			if stage>=3 then
-				industrialtest.internal.makeRubberTree(pointed.under)
-			else
-				meta:set_int("stage",stage)
-			end
-		end
 		minetest.register_abm({
 			label="Rubber sapling growing",
 			nodenames={"industrialtest:rubber_sapling"},
@@ -392,6 +379,23 @@ if not industrialtest.mods.mclRubber then
 				end
 			end
 		})
+		mcl_dye.register_on_bone_meal_apply(function(pointed)
+			local node=minetest.get_node(pointed.under)
+			if node.name~="industrialtest:rubber_sapling" then
+				return
+			end
+			if industrialtest.random:next(1,100)>45 then
+				return
+			end
+			local meta=minetest.get_meta(pointed.under)
+			local stage=meta:get_int("stage") or 0
+			stage=stage+1
+			if stage>=3 then
+					industrialtest.internal.makeRubberTree(pointed.under)
+			else
+				meta:set_int("stage",stage)
+			end
+		end)
 	end
 	definition.groups.attached_node=1
 	definition.groups.dig_immediate=3
@@ -407,85 +411,3 @@ if not industrialtest.mods.mclRubber then
 		})
 	end
 end
-
-definition={
-	description=S("Reinforced Stone"),
-	tiles={"industrialtest_reinforced_stone.png"}
-}
-if industrialtest.mtgAvailable then
-	definition.groups={cracky=3}
-	definition.sounds=default.node_sound_stone_defaults()
-	definition.on_blast=function(pos,intensity)
-		if intensity>20 then
-			minetest.remove_node(pos)
-			minetest.add_item(pos,ItemStack("industrialtest:reinforced_stone"))
-		end
-	end
-elseif industrialtest.mclAvailable then
-	definition.groups={
-		pickaxey=1,
-		stone=1,
-		building_block=1,
-		material_stone=1
-	}
-	definition.sounds=mcl_sounds.node_sound_stone_defaults()
-	definition._mcl_blast_resistance=1200
-	definition._mcl_hardness=5
-end
-minetest.register_node("industrialtest:reinforced_stone",definition)
-minetest.register_craft({
-	type="shaped",
-	output="industrialtest:reinforced_stone 8",
-	recipe={
-		{industrialtest.elementKeys.stone,industrialtest.elementKeys.stone,industrialtest.elementKeys.stone},
-		{industrialtest.elementKeys.stone,"industrialtest:advanced_alloy",industrialtest.elementKeys.stone},
-		{industrialtest.elementKeys.stone,industrialtest.elementKeys.stone,industrialtest.elementKeys.stone}
-	}
-})
-
-definition={
-	description=S("Reinforced Glass"),
-	drawtype="glasslike_framed_optional",
-	tiles={"industrialtest_reinforced_glass.png"},
-	use_texture_alpha="clip",
-	paramtype="light",
-	sunlight_propagates=true
-}
-if industrialtest.mtgAvailable then
-	definition.groups={cracky=3}
-	definition.sounds=default.node_sound_glass_defaults()
-	definition.on_blast=function(pos,intensity)
-		if intensity>10 then
-			minetest.remove_node(pos)
-			minetest.add_item(pos,ItemStack("industrialtest:reinforced_glass"))
-		end
-	end
-elseif industrialtest.mclAvailable then
-	definition.groups={
-		glass=1,
-		building_block=1,
-		material_glass=1
-	}
-	definition.sounds=mcl_sounds.node_sound_glass_defaults()
-	definition._mcl_blast_resistance=15
-	definition._mcl_hardness=1.5
-end
-minetest.register_node("industrialtest:reinforced_glass",definition)
-minetest.register_craft({
-	type="shaped",
-	output="industrialtest:reinforced_glass 7",
-	recipe={
-		{industrialtest.elementKeys.glass,industrialtest.elementKeys.glass,industrialtest.elementKeys.glass},
-		{"industrialtest:advanced_alloy",industrialtest.elementKeys.glass,"industrialtest:advanced_alloy"},
-		{industrialtest.elementKeys.glass,industrialtest.elementKeys.glass,industrialtest.elementKeys.glass}
-	}
-})
-minetest.register_craft({
-	type="shaped",
-	output="industrialtest:reinforced_glass 7",
-	recipe={
-		{industrialtest.elementKeys.glass,"industrialtest:advanced_alloy",industrialtest.elementKeys.glass},
-		{industrialtest.elementKeys.glass,industrialtest.elementKeys.glass,industrialtest.elementKeys.glass},
-		{industrialtest.elementKeys.glass,"industrialtest:advanced_alloy",industrialtest.elementKeys.glass}
-	}
-})

settingtypes.txt

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

textures/SOURCES.md

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