Replace mesecon:<some_function> with mesecon.<some_function> for greater

flexibility and because it was never inteded to be OOP in the first
place.

mesecon.receptor_on and mesecon.receptor_off are provided by wrappers
(mesecon:receptor_on/off) for compatibility, but will be removed. Mod
programmers that use mesecons: Please update!

Also, fix microcontroller polluting the global namespace and remove some
deprecated stuff.

31 files changed, 455 insertions, 488 deletions

diff --git a/mesecons/actionqueue.lua b/mesecons/actionqueue.lua
index e7cbc55..87fcee4 100644
--- a/mesecons/actionqueue.lua
+++ b/mesecons/actionqueue.lua
@@ -12,19 +12,19 @@ function mesecon.queue:add_action(pos, func, params, time, overwritecheck, prior
 	-- Create Action Table:
 	time = time or 0 -- time <= 0 --> execute, time > 0 --> wait time until execution
 	priority = priority or 1
-	local action = {	pos=mesecon:tablecopy(pos),
+	local action = {	pos=mesecon.tablecopy(pos),
 				func=func,
-				params=mesecon:tablecopy(params or {}),
+				params=mesecon.tablecopy(params or {}),
 				time=time,
-				owcheck=(overwritecheck and mesecon:tablecopy(overwritecheck)) or nil,
+				owcheck=(overwritecheck and mesecon.tablecopy(overwritecheck)) or nil,
 				priority=priority}
 
 	local toremove = nil
 	-- Otherwise, add the action to the queue
 	if overwritecheck then -- check if old action has to be overwritten / removed:
 		for i, ac in ipairs(mesecon.queue.actions) do
-			if(mesecon:cmpPos(pos, ac.pos)
-			and mesecon:cmpAny(overwritecheck, ac.owcheck)) then
+			if(mesecon.cmpPos(pos, ac.pos)
+			and mesecon.cmpAny(overwritecheck, ac.owcheck)) then
 				toremove = i
 				break
 			end
@@ -60,7 +60,7 @@ local m_time = 0
 minetest.register_globalstep(function (dtime)
 	m_time = m_time + dtime
 	if (m_time < MESECONS_RESUMETIME) then return end -- don't even try if server has not been running for XY seconds
-	local actions = mesecon:tablecopy(mesecon.queue.actions)
+	local actions = mesecon.tablecopy(mesecon.queue.actions)
 	local actions_now={}
 
 	mesecon.queue.actions = {}
diff --git a/mesecons/init.lua b/mesecons/init.lua
index c74b60b..a1a3149 100644
--- a/mesecons/init.lua
+++ b/mesecons/init.lua
@@ -78,8 +78,8 @@ mesecon.queue:add_function("receptor_on", function (pos, rules)
 	rules = rules or mesecon.rules.default
 
 	-- if area (any of the rule targets) is not loaded, keep trying and call this again later
-	for _, rule in ipairs(mesecon:flattenrules(rules)) do
-		local np = mesecon:addPosRule(pos, rule)
+	for _, rule in ipairs(mesecon.flattenrules(rules)) do
+		local np = mesecon.addPosRule(pos, rule)
 		-- if area is not loaded, keep trying
 		if minetest.get_node_or_nil(np) == nil then
 			mesecon.queue:add_action(pos, "receptor_on", {rules}, nil, rules)
@@ -88,16 +88,16 @@ mesecon.queue:add_function("receptor_on", function (pos, rules)
 	end
 
 	-- execute action
-	for _, rule in ipairs(mesecon:flattenrules(rules)) do
-		local np = mesecon:addPosRule(pos, rule)
-		local rulenames = mesecon:rules_link_rule_all(pos, rule)
+	for _, rule in ipairs(mesecon.flattenrules(rules)) do
+		local np = mesecon.addPosRule(pos, rule)
+		local rulenames = mesecon.rules_link_rule_all(pos, rule)
 		for _, rulename in ipairs(rulenames) do
-			mesecon:turnon(np, rulename)
+			mesecon.turnon(np, rulename)
 		end
 	end
 end)
 
-function mesecon:receptor_on(pos, rules)
+function mesecon.receptor_on(pos, rules)
 	mesecon.queue:add_action(pos, "receptor_on", {rules}, nil, rules)
 end
 
@@ -105,28 +105,28 @@ mesecon.queue:add_function("receptor_off", function (pos, rules)
 	rules = rules or mesecon.rules.default
 
 	-- if area (any of the rule targets) is not loaded, keep trying and call this again later
-	for _, rule in ipairs(mesecon:flattenrules(rules)) do
-		local np = mesecon:addPosRule(pos, rule)
+	for _, rule in ipairs(mesecon.flattenrules(rules)) do
+		local np = mesecon.addPosRule(pos, rule)
 		if minetest.get_node_or_nil(np) == nil then
 			mesecon.queue:add_action(pos, "receptor_off", {rules}, nil, rules)
 			return
 		end
 	end
 
-	for _, rule in ipairs(mesecon:flattenrules(rules)) do
-		local np = mesecon:addPosRule(pos, rule)
-		local rulenames = mesecon:rules_link_rule_all(pos, rule)
+	for _, rule in ipairs(mesecon.flattenrules(rules)) do
+		local np = mesecon.addPosRule(pos, rule)
+		local rulenames = mesecon.rules_link_rule_all(pos, rule)
 		for _, rulename in ipairs(rulenames) do
-			if not mesecon:connected_to_receptor(np, mesecon:invertRule(rule)) then
-				mesecon:turnoff(np, rulename)
+			if not mesecon.connected_to_receptor(np, mesecon.invertRule(rule)) then
+				mesecon.turnoff(np, rulename)
 			else
-				mesecon:changesignal(np, minetest.get_node(np), rulename, mesecon.state.off, 2)
+				mesecon.changesignal(np, minetest.get_node(np), rulename, mesecon.state.off, 2)
 			end
 		end
 	end
 end)
 
-function mesecon:receptor_off(pos, rules)
+function mesecon.receptor_off(pos, rules)
 	mesecon.queue:add_action(pos, "receptor_off", {rules}, nil, rules)
 end
 
diff --git a/mesecons/internal.lua b/mesecons/internal.lua
index 75d7785..ec0d03c 100644
--- a/mesecons/internal.lua
+++ b/mesecons/internal.lua
@@ -3,56 +3,56 @@
 -- For more practical developer resources see mesecons.tk
 --
 -- Function overview
--- mesecon:get_effector(nodename)     --> Returns the mesecons.effector -specifictation in the nodedef by the nodename
--- mesecon:get_receptor(nodename)     --> Returns the mesecons.receptor -specifictation in the nodedef by the nodename
--- mesecon:get_conductor(nodename)    --> Returns the mesecons.conductor-specifictation in the nodedef by the nodename
--- mesecon:get_any_inputrules (node)  --> Returns the rules of a node if it is a conductor or an effector
--- mesecon:get_any_outputrules (node) --> Returns the rules of a node if it is a conductor or a receptor
+-- mesecon.get_effector(nodename)     --> Returns the mesecons.effector -specifictation in the nodedef by the nodename
+-- mesecon.get_receptor(nodename)     --> Returns the mesecons.receptor -specifictation in the nodedef by the nodename
+-- mesecon.get_conductor(nodename)    --> Returns the mesecons.conductor-specifictation in the nodedef by the nodename
+-- mesecon.get_any_inputrules (node)  --> Returns the rules of a node if it is a conductor or an effector
+-- mesecon.get_any_outputrules (node) --> Returns the rules of a node if it is a conductor or a receptor
 
 -- RECEPTORS
--- mesecon:is_receptor(nodename)     --> Returns true if nodename is a receptor
--- mesecon:is_receptor_on(nodename)  --> Returns true if nodename is an receptor with state = mesecon.state.on
--- mesecon:is_receptor_off(nodename) --> Returns true if nodename is an receptor with state = mesecon.state.off
--- mesecon:receptor_get_rules(node)  --> Returns the rules of the receptor (mesecon.rules.default if none specified)
+-- mesecon.is_receptor(nodename)     --> Returns true if nodename is a receptor
+-- mesecon.is_receptor_on(nodename)  --> Returns true if nodename is an receptor with state = mesecon.state.on
+-- mesecon.is_receptor_off(nodename) --> Returns true if nodename is an receptor with state = mesecon.state.off
+-- mesecon.receptor_get_rules(node)  --> Returns the rules of the receptor (mesecon.rules.default if none specified)
 
 -- EFFECTORS
--- mesecon:is_effector(nodename)     --> Returns true if nodename is an effector
--- mesecon:is_effector_on(nodename)  --> Returns true if nodename is an effector with nodedef.mesecons.effector.action_off
--- mesecon:is_effector_off(nodename) --> Returns true if nodename is an effector with nodedef.mesecons.effector.action_on
--- mesecon:effector_get_rules(node)  --> Returns the input rules of the effector (mesecon.rules.default if none specified)
+-- mesecon.is_effector(nodename)     --> Returns true if nodename is an effector
+-- mesecon.is_effector_on(nodename)  --> Returns true if nodename is an effector with nodedef.mesecons.effector.action_off
+-- mesecon.is_effector_off(nodename) --> Returns true if nodename is an effector with nodedef.mesecons.effector.action_on
+-- mesecon.effector_get_rules(node)  --> Returns the input rules of the effector (mesecon.rules.default if none specified)
 
 -- SIGNALS
--- mesecon:activate(pos, node, depth)		--> Activates   the effector node at the specific pos (calls nodedef.mesecons.effector.action_on), higher depths are executed later
--- mesecon:deactivate(pos, node, depth)		--> Deactivates the effector node at the specific pos (calls nodedef.mesecons.effector.action_off), higher depths are executed later
--- mesecon:changesignal(pos, node, rulename, newstate, depth)	--> Changes     the effector node at the specific pos (calls nodedef.mesecons.effector.action_change), higher depths are executed later
+-- mesecon.activate(pos, node, depth)		--> Activates   the effector node at the specific pos (calls nodedef.mesecons.effector.action_on), higher depths are executed later
+-- mesecon.deactivate(pos, node, depth)		--> Deactivates the effector node at the specific pos (calls nodedef.mesecons.effector.action_off), higher depths are executed later
+-- mesecon.changesignal(pos, node, rulename, newstate, depth)	--> Changes     the effector node at the specific pos (calls nodedef.mesecons.effector.action_change), higher depths are executed later
 
 -- CONDUCTORS
--- mesecon:is_conductor(nodename)     --> Returns true if nodename is a conductor
--- mesecon:is_conductor_on(node)  --> Returns true if node is a conductor with state = mesecon.state.on
--- mesecon:is_conductor_off(node) --> Returns true if node is a conductor with state = mesecon.state.off
--- mesecon:get_conductor_on(node_off) --> Returns the onstate  nodename of the conductor
--- mesecon:get_conductor_off(node_on) --> Returns the offstate nodename of the conductor
--- mesecon:conductor_get_rules(node)  --> Returns the input+output rules of a conductor (mesecon.rules.default if none specified)
+-- mesecon.is_conductor(nodename)     --> Returns true if nodename is a conductor
+-- mesecon.is_conductor_on(node)  --> Returns true if node is a conductor with state = mesecon.state.on
+-- mesecon.is_conductor_off(node) --> Returns true if node is a conductor with state = mesecon.state.off
+-- mesecon.get_conductor_on(node_off) --> Returns the onstate  nodename of the conductor
+-- mesecon.get_conductor_off(node_on) --> Returns the offstate nodename of the conductor
+-- mesecon.conductor_get_rules(node)  --> Returns the input+output rules of a conductor (mesecon.rules.default if none specified)
 
 -- HIGH-LEVEL Internals
--- mesecon:is_power_on(pos)             --> Returns true if pos emits power in any way
--- mesecon:is_power_off(pos)            --> Returns true if pos does not emit power in any way
--- mesecon:turnon(pos, rulename)        --> Returns true  whatever there is at pos. Calls itself for connected nodes (if pos is a conductor) --> recursive, the rulename is the name of the input rule that caused calling turnon; Uses third parameter recdepth internally to determine how far away the current node is from the initial pos as it uses recursion
--- mesecon:turnoff(pos, rulename)       --> Turns off whatever there is at pos. Calls itself for connected nodes (if pos is a conductor) --> recursive, the rulename is the name of the input rule that caused calling turnoff; Uses third parameter recdepth internally to determine how far away the current node is from the initial pos as it uses recursion
--- mesecon:connected_to_receptor(pos)   --> Returns true if pos is connected to a receptor directly or via conductors; calls itself if pos is a conductor --> recursive
--- mesecon:rules_link(output, input, dug_outputrules) --> Returns true if outputposition + outputrules = inputposition and inputposition + inputrules = outputposition (if the two positions connect)
--- mesecon:rules_link_anydir(outp., inp., d_outpr.)   --> Same as rules mesecon:rules_link but also returns true if output and input are swapped
--- mesecon:is_powered(pos)              --> Returns true if pos is powered by a receptor or a conductor
+-- mesecon.is_power_on(pos)             --> Returns true if pos emits power in any way
+-- mesecon.is_power_off(pos)            --> Returns true if pos does not emit power in any way
+-- mesecon.turnon(pos, rulename)        --> Returns true  whatever there is at pos. Calls itself for connected nodes (if pos is a conductor) --> recursive, the rulename is the name of the input rule that caused calling turnon; Uses third parameter recdepth internally to determine how far away the current node is from the initial pos as it uses recursion
+-- mesecon.turnoff(pos, rulename)       --> Turns off whatever there is at pos. Calls itself for connected nodes (if pos is a conductor) --> recursive, the rulename is the name of the input rule that caused calling turnoff; Uses third parameter recdepth internally to determine how far away the current node is from the initial pos as it uses recursion
+-- mesecon.connected_to_receptor(pos)   --> Returns true if pos is connected to a receptor directly or via conductors; calls itself if pos is a conductor --> recursive
+-- mesecon.rules_link(output, input, dug_outputrules) --> Returns true if outputposition + outputrules = inputposition and inputposition + inputrules = outputposition (if the two positions connect)
+-- mesecon.rules_link_anydir(outp., inp., d_outpr.)   --> Same as rules mesecon.rules_link but also returns true if output and input are swapped
+-- mesecon.is_powered(pos)              --> Returns true if pos is powered by a receptor or a conductor
 
 -- RULES ROTATION helpsers
--- mesecon:rotate_rules_right(rules)
--- mesecon:rotate_rules_left(rules)
--- mesecon:rotate_rules_up(rules)
--- mesecon:rotate_rules_down(rules)
+-- mesecon.rotate_rules_right(rules)
+-- mesecon.rotate_rules_left(rules)
+-- mesecon.rotate_rules_up(rules)
+-- mesecon.rotate_rules_down(rules)
 -- These functions return rules that have been rotated in the specific direction
 
 -- General
-function mesecon:get_effector(nodename)
+function mesecon.get_effector(nodename)
 	if  minetest.registered_nodes[nodename]
 	and minetest.registered_nodes[nodename].mesecons
 	and minetest.registered_nodes[nodename].mesecons.effector then
@@ -60,7 +60,7 @@ function mesecon:get_effector(nodename)
 	end
 end
 
-function mesecon:get_receptor(nodename)
+function mesecon.get_receptor(nodename)
 	if  minetest.registered_nodes[nodename]
 	and minetest.registered_nodes[nodename].mesecons
 	and minetest.registered_nodes[nodename].mesecons.receptor then
@@ -68,7 +68,7 @@ function mesecon:get_receptor(nodename)
 	end
 end
 
-function mesecon:get_conductor(nodename)
+function mesecon.get_conductor(nodename)
 	if  minetest.registered_nodes[nodename]
 	and minetest.registered_nodes[nodename].mesecons
 	and minetest.registered_nodes[nodename].mesecons.conductor then
@@ -76,52 +76,52 @@ function mesecon:get_conductor(nodename)
 	end
 end
 
-function mesecon:get_any_outputrules (node)
-	if mesecon:is_conductor(node.name) then
-		return mesecon:conductor_get_rules(node)
-	elseif mesecon:is_receptor(node.name) then
-		return mesecon:receptor_get_rules(node)
+function mesecon.get_any_outputrules (node)
+	if mesecon.is_conductor(node.name) then
+		return mesecon.conductor_get_rules(node)
+	elseif mesecon.is_receptor(node.name) then
+		return mesecon.receptor_get_rules(node)
 	end
 	return false
 end
 
-function mesecon:get_any_inputrules (node)
-	if mesecon:is_conductor(node.name) then
-		return mesecon:conductor_get_rules(node)
-	elseif mesecon:is_effector(node.name) then
-		return mesecon:effector_get_rules(node)
+function mesecon.get_any_inputrules (node)
+	if mesecon.is_conductor(node.name) then
+		return mesecon.conductor_get_rules(node)
+	elseif mesecon.is_effector(node.name) then
+		return mesecon.effector_get_rules(node)
 	end
 	return false
 end
 
 -- Receptors
 -- Nodes that can power mesecons
-function mesecon:is_receptor_on(nodename)
-	local receptor = mesecon:get_receptor(nodename)
+function mesecon.is_receptor_on(nodename)
+	local receptor = mesecon.get_receptor(nodename)
 	if receptor and receptor.state == mesecon.state.on then
 		return true
 	end
 	return false
 end
 
-function mesecon:is_receptor_off(nodename)
-	local receptor = mesecon:get_receptor(nodename)
+function mesecon.is_receptor_off(nodename)
+	local receptor = mesecon.get_receptor(nodename)
 	if receptor and receptor.state == mesecon.state.off then
 		return true
 	end
 	return false
 end
 
-function mesecon:is_receptor(nodename)
-	local receptor = mesecon:get_receptor(nodename)
+function mesecon.is_receptor(nodename)
+	local receptor = mesecon.get_receptor(nodename)
 	if receptor then
 		return true
 	end
 	return false
 end
 
-function mesecon:receptor_get_rules(node)
-	local receptor = mesecon:get_receptor(node.name)
+function mesecon.receptor_get_rules(node)
+	local receptor = mesecon.get_receptor(node.name)
 	if receptor then
 		local rules = receptor.rules
 		if type(rules) == 'function' then
@@ -136,32 +136,32 @@ end
 
 -- Effectors
 -- Nodes that can be powered by mesecons
-function mesecon:is_effector_on(nodename)
-	local effector = mesecon:get_effector(nodename)
+function mesecon.is_effector_on(nodename)
+	local effector = mesecon.get_effector(nodename)
 	if effector and effector.action_off then
 		return true
 	end
 	return false
 end
 
-function mesecon:is_effector_off(nodename)
-	local effector = mesecon:get_effector(nodename)
+function mesecon.is_effector_off(nodename)
+	local effector = mesecon.get_effector(nodename)
 	if effector and effector.action_on then
 		return true
 	end
 	return false
 end
 
-function mesecon:is_effector(nodename)
-	local effector = mesecon:get_effector(nodename)
+function mesecon.is_effector(nodename)
+	local effector = mesecon.get_effector(nodename)
 	if effector then
 		return true
 	end
 	return false
 end
 
-function mesecon:effector_get_rules(node)
-	local effector = mesecon:get_effector(node.name)
+function mesecon.effector_get_rules(node)
+	local effector = mesecon.get_effector(node.name)
 	if effector then
 		local rules = effector.rules
 		if type(rules) == 'function' then
@@ -180,17 +180,17 @@ end
 -- Activation:
 mesecon.queue:add_function("activate", function (pos, rulename)
 	node = minetest.get_node(pos)
-	effector = mesecon:get_effector(node.name)
+	effector = mesecon.get_effector(node.name)
 
 	if effector and effector.action_on then
 		effector.action_on(pos, node, rulename)
 	end
 end)
 
-function mesecon:activate(pos, node, rulename, depth)
+function mesecon.activate(pos, node, rulename, depth)
 	if rulename == nil then
-		for _,rule in ipairs(mesecon:effector_get_rules(node)) do
-			mesecon:activate(pos, node, rule, depth + 1)
+		for _,rule in ipairs(mesecon.effector_get_rules(node)) do
+			mesecon.activate(pos, node, rule, depth + 1)
 		end
 		return
 	end
@@ -201,17 +201,17 @@ end
 -- Deactivation
 mesecon.queue:add_function("deactivate", function (pos, rulename)
 	node = minetest.get_node(pos)
-	effector = mesecon:get_effector(node.name)
+	effector = mesecon.get_effector(node.name)
 
 	if effector and effector.action_off then
 		effector.action_off(pos, node, rulename)
 	end
 end)
 
-function mesecon:deactivate(pos, node, rulename, depth)
+function mesecon.deactivate(pos, node, rulename, depth)
 	if rulename == nil then
-		for _,rule in ipairs(mesecon:effector_get_rules(node)) do
-			mesecon:deactivate(pos, node, rule, depth + 1)
+		for _,rule in ipairs(mesecon.effector_get_rules(node)) do
+			mesecon.deactivate(pos, node, rule, depth + 1)
 		end
 		return
 	end
@@ -222,17 +222,17 @@ end
 -- Change
 mesecon.queue:add_function("change", function (pos, rulename, changetype)
 	local node = minetest.get_node(pos)
-	local effector = mesecon:get_effector(node.name)
+	local effector = mesecon.get_effector(node.name)
 
 	if effector and effector.action_change then
 		effector.action_change(pos, node, rulename, changetype)
 	end
 end)
 
-function mesecon:changesignal(pos, node, rulename, newstate, depth)
+function mesecon.changesignal(pos, node, rulename, newstate, depth)
 	if rulename == nil then
-		for _,rule in ipairs(mesecon:effector_get_rules(node)) do
-			mesecon:changesignal(pos, node, rule, newstate, depth + 1)
+		for _,rule in ipairs(mesecon.effector_get_rules(node)) do
+			mesecon.changesignal(pos, node, rule, newstate, depth + 1)
 		end
 		return
 	end
@@ -242,84 +242,84 @@ end
 
 -- Conductors
 
-function mesecon:is_conductor_on(node, rulename)
-	local conductor = mesecon:get_conductor(node.name)
+function mesecon.is_conductor_on(node, rulename)
+	local conductor = mesecon.get_conductor(node.name)
 	if conductor then
 		if conductor.state then
 			return conductor.state == mesecon.state.on
 		end
 		if conductor.states then
 			if not rulename then
-				return mesecon:getstate(node.name, conductor.states) ~= 1
+				return mesecon.getstate(node.name, conductor.states) ~= 1
 			end
-			local bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node))
-			local binstate = mesecon:getbinstate(node.name, conductor.states)
-			return mesecon:get_bit(binstate, bit)
+			local bit = mesecon.rule2bit(rulename, mesecon.conductor_get_rules(node))
+			local binstate = mesecon.getbinstate(node.name, conductor.states)
+			return mesecon.get_bit(binstate, bit)
 		end
 	end
 	return false
 end
 
-function mesecon:is_conductor_off(node, rulename)
-	local conductor = mesecon:get_conductor(node.name)
+function mesecon.is_conductor_off(node, rulename)
+	local conductor = mesecon.get_conductor(node.name)
 	if conductor then
 		if conductor.state then
 			return conductor.state == mesecon.state.off
 		end
 		if conductor.states then
 			if not rulename then
-				return mesecon:getstate(node.name, conductor.states) == 1
+				return mesecon.getstate(node.name, conductor.states) == 1
 			end
-			local bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node))
-			local binstate = mesecon:getbinstate(node.name, conductor.states)
-			return not mesecon:get_bit(binstate, bit)
+			local bit = mesecon.rule2bit(rulename, mesecon.conductor_get_rules(node))
+			local binstate = mesecon.getbinstate(node.name, conductor.states)
+			return not mesecon.get_bit(binstate, bit)
 		end
 	end
 	return false
 end
 
-function mesecon:is_conductor(nodename)
-	local conductor = mesecon:get_conductor(nodename)
+function mesecon.is_conductor(nodename)
+	local conductor = mesecon.get_conductor(nodename)
 	if conductor then
 		return true
 	end
 	return false
 end
 
-function mesecon:get_conductor_on(node_off, rulename)
-	local conductor = mesecon:get_conductor(node_off.name)
+function mesecon.get_conductor_on(node_off, rulename)
+	local conductor = mesecon.get_conductor(node_off.name)
 	if conductor then
 		if conductor.onstate then
 			return conductor.onstate
 		end
 		if conductor.states then
-			local bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node_off))
-			local binstate = mesecon:getbinstate(node_off.name, conductor.states)
-			binstate = mesecon:set_bit(binstate, bit, "1")
+			local bit = mesecon.rule2bit(rulename, mesecon.conductor_get_rules(node_off))
+			local binstate = mesecon.getbinstate(node_off.name, conductor.states)
+			binstate = mesecon.set_bit(binstate, bit, "1")
 			return conductor.states[tonumber(binstate,2)+1]
 		end
 	end
 	return offstate
 end
 
-function mesecon:get_conductor_off(node_on, rulename)
-	local conductor = mesecon:get_conductor(node_on.name)
+function mesecon.get_conductor_off(node_on, rulename)
+	local conductor = mesecon.get_conductor(node_on.name)
 	if conductor then
 		if conductor.offstate then
 			return conductor.offstate
 		end
 		if conductor.states then
-			local bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node_on))
-			local binstate = mesecon:getbinstate(node_on.name, conductor.states)
-			binstate = mesecon:set_bit(binstate, bit, "0")
+			local bit = mesecon.rule2bit(rulename, mesecon.conductor_get_rules(node_on))
+			local binstate = mesecon.getbinstate(node_on.name, conductor.states)
+			binstate = mesecon.set_bit(binstate, bit, "0")
 			return conductor.states[tonumber(binstate,2)+1]
 		end
 	end
 	return onstate
 end
 
-function mesecon:conductor_get_rules(node)
-	local conductor = mesecon:get_conductor(node.name)
+function mesecon.conductor_get_rules(node)
+	local conductor = mesecon.get_conductor(node.name)
 	if conductor then
 		local rules = conductor.rules
 		if type(rules) == 'function' then
@@ -333,23 +333,23 @@ end
 
 -- some more general high-level stuff
 
-function mesecon:is_power_on(pos, rulename)
+function mesecon.is_power_on(pos, rulename)
 	local node = minetest.get_node(pos)
-	if mesecon:is_conductor_on(node, rulename) or mesecon:is_receptor_on(node.name) then
+	if mesecon.is_conductor_on(node, rulename) or mesecon.is_receptor_on(node.name) then
 		return true
 	end
 	return false
 end
 
-function mesecon:is_power_off(pos, rulename)
+function mesecon.is_power_off(pos, rulename)
 	local node = minetest.get_node(pos)
-	if mesecon:is_conductor_off(node, rulename) or mesecon:is_receptor_off(node.name) then
+	if mesecon.is_conductor_off(node, rulename) or mesecon.is_receptor_off(node.name) then
 		return true
 	end
 	return false
 end
 
-function mesecon:turnon(pos, link)
+function mesecon.turnon(pos, link)
 	local frontiers = {{pos = pos, link = link}}
 
 	local depth = 1
@@ -362,31 +362,31 @@ function mesecon:turnon(pos, link)
 			mesecon.queue:add_action(f.pos, "turnon", {link}, nil, true)
 		end
 
-		if mesecon:is_conductor_off(node, f.link) then
-			local rules = mesecon:conductor_get_rules(node)
+		if mesecon.is_conductor_off(node, f.link) then
+			local rules = mesecon.conductor_get_rules(node)
 
-			minetest.swap_node(f.pos, {name = mesecon:get_conductor_on(node, f.link),
+			minetest.swap_node(f.pos, {name = mesecon.get_conductor_on(node, f.link),
 				param2 = node.param2})
 
 			-- call turnon on neighbors: normal rules
-			for _, r in ipairs(mesecon:rule2meta(f.link, rules)) do
-				local np = mesecon:addPosRule(f.pos, r)
+			for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
+				local np = mesecon.addPosRule(f.pos, r)
 
 				-- area not loaded, postpone action
 				if not minetest.get_node_or_nil(np) then
 					mesecon.queue:add_action(np, "turnon", {rulename},
 						nil, true)
 				else
-					local links = mesecon:rules_link_rule_all(f.pos, r)
+					local links = mesecon.rules_link_rule_all(f.pos, r)
 					for _, l in ipairs(links) do
 						table.insert(frontiers, {pos = np, link = l})
 					end
 				end
 			end
-		elseif mesecon:is_effector(node.name) then
-			mesecon:changesignal(f.pos, node, f.link, mesecon.state.on, depth)
-			if mesecon:is_effector_off(node.name) then
-				mesecon:activate(f.pos, node, f.link, depth)
+		elseif mesecon.is_effector(node.name) then
+			mesecon.changesignal(f.pos, node, f.link, mesecon.state.on, depth)
+			if mesecon.is_effector_off(node.name) then
+				mesecon.activate(f.pos, node, f.link, depth)
 			end
 		end
 		depth = depth + 1
@@ -394,10 +394,10 @@ function mesecon:turnon(pos, link)
 end
 
 mesecon.queue:add_function("turnon", function (pos, rulename, recdepth)
-	mesecon:turnon(pos, rulename, recdepth)
+	mesecon.turnon(pos, rulename, recdepth)
 end)
 
-function mesecon:turnoff(pos, link)
+function mesecon.turnoff(pos, link)
 	local frontiers = {{pos = pos, link = link}}
 
 	local depth = 1
@@ -410,31 +410,31 @@ function mesecon:turnoff(pos, link)
 			mesecon.queue:add_action(f.pos, "turnoff", {link}, nil, true)
 		end
 
-		if mesecon:is_conductor_on(node, f.link) then
-			local rules = mesecon:conductor_get_rules(node)
+		if mesecon.is_conductor_on(node, f.link) then
+			local rules = mesecon.conductor_get_rules(node)
 
-			minetest.swap_node(f.pos, {name = mesecon:get_conductor_off(node, f.link),
+			minetest.swap_node(f.pos, {name = mesecon.get_conductor_off(node, f.link),
 				param2 = node.param2})
 
 			-- call turnoff on neighbors: normal rules
-			for _, r in ipairs(mesecon:rule2meta(f.link, rules)) do
-				local np = mesecon:addPosRule(f.pos, r)
+			for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
+				local np = mesecon.addPosRule(f.pos, r)
 
 				-- area not loaded, postpone action
 				if not minetest.get_node_or_nil(np) then
 					mesecon.queue:add_action(np, "turnoff", {rulename},
 						nil, true)
 				else
-					local links = mesecon:rules_link_rule_all(f.pos, r)
+					local links = mesecon.rules_link_rule_all(f.pos, r)
 					for _, l in ipairs(links) do
 						table.insert(frontiers, {pos = np, link = l})
 					end
 				end
 			end
-		elseif mesecon:is_effector(node.name) then
-			mesecon:changesignal(f.pos, node, f.link, mesecon.state.off, depth)
-			if mesecon:is_effector_on(node.name) and not mesecon:is_powered(f.pos) then
-				mesecon:deactivate(f.pos, node, f.link, depth)
+		elseif mesecon.is_effector(node.name) then
+			mesecon.changesignal(f.pos, node, f.link, mesecon.state.off, depth)
+			if mesecon.is_effector_on(node.name) and not mesecon.is_powered(f.pos) then
+				mesecon.deactivate(f.pos, node, f.link, depth)
 			end
 		end
 		depth = depth + 1
@@ -442,22 +442,22 @@ function mesecon:turnoff(pos, link)
 end
 
 mesecon.queue:add_function("turnoff", function (pos, rulename, recdepth)
-	mesecon:turnoff(pos, rulename, recdepth)
+	mesecon.turnoff(pos, rulename, recdepth)
 end)
 
 
-function mesecon:connected_to_receptor(pos, rulename)
+function mesecon.connected_to_receptor(pos, rulename)
 	local node = minetest.get_node(pos)
 
 	-- Check if conductors around are connected
-	local rules = mesecon:get_any_inputrules(node)
+	local rules = mesecon.get_any_inputrules(node)
 	if not rules then return false end
 
-	for _, rule in ipairs(mesecon:rule2meta(rulename, rules)) do
-		local rulenames = mesecon:rules_link_rule_all_inverted(pos, rule)
+	for _, rule in ipairs(mesecon.rule2meta(rulename, rules)) do
+		local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
 		for _, rname in ipairs(rulenames) do
-			local np = mesecon:addPosRule(pos, rname)
-			if mesecon:find_receptor_on(np, {}, mesecon:invertRule(rname)) then
+			local np = mesecon.addPosRule(pos, rname)
+			if mesecon.find_receptor_on(np, {}, mesecon.invertRule(rname)) then
 				return true
 			end
 		end
@@ -466,33 +466,34 @@ function mesecon:connected_to_receptor(pos, rulename)
 	return false
 end
 
-function mesecon:find_receptor_on(pos, checked, rulename, recdepth)
+function mesecon.find_receptor_on(pos, checked, rulename, recdepth)
 	recdepth = recdepth or 2
 	if (recdepth > STACK_SIZE) then return true end -- ignore request
 	local node = minetest.get_node(pos)
 
-	if mesecon:is_receptor_on(node.name) then
+	if mesecon.is_receptor_on(node.name) then
 		-- add current position to checked
 		table.insert(checked, {x=pos.x, y=pos.y, z=pos.z})
 		return true
 	end
 
-	if mesecon:is_conductor(node.name) then
-		local rules = mesecon:conductor_get_rules(node)
-		local metaindex = mesecon:rule2metaindex(rulename, rules)
+	if mesecon.is_conductor(node.name) then
+		local rules = mesecon.conductor_get_rules(node)
+		local metaindex = mesecon.rule2metaindex(rulename, rules)
 		-- find out if node has already been checked (to prevent from endless loop)
 		for _, cp in ipairs(checked) do
-			if mesecon:cmpPos(cp, pos) and cp.metaindex == metaindex then
+			if mesecon.cmpPos(cp, pos) and cp.metaindex == metaindex then
 				return false, checked
 			end
 		end
 		-- add current position to checked
 		table.insert(checked, {x=pos.x, y=pos.y, z=pos.z, metaindex = metaindex})
-		for _, rule in ipairs(mesecon:rule2meta(rulename, rules)) do
-			local rulenames = mesecon:rules_link_rule_all_inverted(pos, rule)
+		for _, rule in ipairs(mesecon.rule2meta(rulename, rules)) do
+			local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
 			for _, rname in ipairs(rulenames) do
-				local np = mesecon:addPosRule(pos, rname)
-				if mesecon:find_receptor_on(np, checked, mesecon:invertRule(rname), recdepth + 1) then
+				local np = mesecon.addPosRule(pos, rname)
+				if mesecon.find_receptor_on(np, checked, mesecon.invertRule(rname),
+					recdepth + 1) then
 					return true
 				end
 			end
@@ -500,7 +501,7 @@ function mesecon:find_receptor_on(pos, checked, rulename, recdepth)
 	else
 		-- find out if node has already been checked (to prevent from endless loop)
 		for _, cp in ipairs(checked) do
-			if mesecon:cmpPos(cp, pos) then
+			if mesecon.cmpPos(cp, pos) then
 				return false, checked
 			end
 		end
@@ -510,22 +511,23 @@ function mesecon:find_receptor_on(pos, checked, rulename, recdepth)
 	return false
 end
 
-function mesecon:rules_link(output, input, dug_outputrules) --output/input are positions (outputrules optional, used if node has been dug), second return value: the name of the affected input rule
+function mesecon.rules_link(output, input, dug_outputrules) --output/input are positions (outputrules optional, used if node has been dug), second return value: the name of the affected input rule
 	local outputnode = minetest.get_node(output)
 	local inputnode = minetest.get_node(input)
-	local outputrules = dug_outputrules or mesecon:get_any_outputrules (outputnode)
-	local inputrules = mesecon:get_any_inputrules (inputnode)
+	local outputrules = dug_outputrules or mesecon.get_any_outputrules (outputnode)
+	local inputrules = mesecon.get_any_inputrules (inputnode)
 	if not outputrules or not inputrules then
 		return
 	end
 
-	for _, outputrule in ipairs(mesecon:flattenrules(outputrules)) do
+	for _, outputrule in ipairs(mesecon.flattenrules(outputrules)) do
 		-- Check if output sends to input
-		if mesecon:cmpPos(mesecon:addPosRule(output, outputrule), input) then
-			for _, inputrule in ipairs(mesecon:flattenrules(inputrules)) do
+		if mesecon.cmpPos(mesecon.addPosRule(output, outputrule), input) then
+			for _, inputrule in ipairs(mesecon.flattenrules(inputrules)) do
 				-- Check if input accepts from output
-				if  mesecon:cmpPos(mesecon:addPosRule(input, inputrule), output) then
-					if inputrule.sx == nil or outputrule.sx == nil or mesecon:cmpSpecial(inputrule, outputrule) then
+				if  mesecon.cmpPos(mesecon.addPosRule(input, inputrule), output) then
+					if inputrule.sx == nil or outputrule.sx == nil
+					or mesecon.cmpSpecial(inputrule, outputrule) then
 						return true, inputrule
 					end
 				end
@@ -535,19 +537,20 @@ function mesecon:rules_link(output, input, dug_outputrules) --output/input are p
 	return false
 end
 
-function mesecon:rules_link_rule_all(output, rule)
-	local input = mesecon:addPosRule(output, rule)
+function mesecon.rules_link_rule_all(output, rule)
+	local input = mesecon.addPosRule(output, rule)
 	local inputnode = minetest.get_node(input)
-	local inputrules = mesecon:get_any_inputrules (inputnode)
+	local inputrules = mesecon.get_any_inputrules (inputnode)
 	if not inputrules then
 		return {}
 	end
 	local rules = {}
 	
-	for _, inputrule in ipairs(mesecon:flattenrules(inputrules)) do
+	for _, inputrule in ipairs(mesecon.flattenrules(inputrules)) do
 		-- Check if input accepts from output
-		if  mesecon:cmpPos(mesecon:addPosRule(input, inputrule), output) then
-			if inputrule.sx == nil or rule.sx == nil or mesecon:cmpSpecial(inputrule, rule) then
+		if  mesecon.cmpPos(mesecon.addPosRule(input, inputrule), output) then
+			if inputrule.sx == nil or rule.sx == nil
+			or mesecon.cmpSpecial(inputrule, rule) then
 				rules[#rules+1] = inputrule
 			end
 		end
@@ -555,56 +558,58 @@ function mesecon:rules_link_rule_all(output, rule)
 	return rules
 end
 
-function mesecon:rules_link_rule_all_inverted(input, rule)
-	--local irule = mesecon:invertRule(rule)
-	local output = mesecon:addPosRule(input, rule)
+function mesecon.rules_link_rule_all_inverted(input, rule)
+	--local irule = mesecon.invertRule(rule)
+	local output = mesecon.addPosRule(input, rule)
 	local outputnode = minetest.get_node(output)
-	local outputrules = mesecon:get_any_outputrules (outputnode)
+	local outputrules = mesecon.get_any_outputrules (outputnode)
 	if not outputrules then
 		return {}
 	end
 	local rules = {}
 	
-	for _, outputrule in ipairs(mesecon:flattenrules(outputrules)) do
-		if  mesecon:cmpPos(mesecon:addPosRule(output, outputrule), input) then
-			if outputrule.sx == nil or rule.sx == nil or mesecon:cmpSpecial(outputrule, rule) then
-				rules[#rules+1] = mesecon:invertRule(outputrule)
+	for _, outputrule in ipairs(mesecon.flattenrules(outputrules)) do
+		if  mesecon.cmpPos(mesecon.addPosRule(output, outputrule), input) then
+			if outputrule.sx == nil or rule.sx == nil
+			or mesecon.cmpSpecial(outputrule, rule) then
+				rules[#rules+1] = mesecon.invertRule(outputrule)
 			end
 		end
 	end
 	return rules
 end
 
-function mesecon:rules_link_anydir(pos1, pos2)
-	return mesecon:rules_link(pos1, pos2) or mesecon:rules_link(pos2, pos1)
+function mesecon.rules_link_anydir(pos1, pos2)
+	return mesecon.rules_link(pos1, pos2) or mesecon.rules_link(pos2, pos1)
 end
 
-function mesecon:is_powered(pos, rule)
+function mesecon.is_powered(pos, rule)
 	local node = minetest.get_node(pos)
-	local rules = mesecon:get_any_inputrules(node)
+	local rules = mesecon.get_any_inputrules(node)
 	if not rules then return false end
 
 	-- List of nodes that send out power to pos
 	local sourcepos = {}
 
 	if not rule then
-		for _, rule in ipairs(mesecon:flattenrules(rules)) do
-			local rulenames = mesecon:rules_link_rule_all_inverted(pos, rule)
+		for _, rule in ipairs(mesecon.flattenrules(rules)) do
+			local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
 			for _, rname in ipairs(rulenames) do
-				local np = mesecon:addPosRule(pos, rname)
+				local np = mesecon.addPosRule(pos, rname)
 				local nn = minetest.get_node(np)
-				if (mesecon:is_conductor_on (nn, mesecon:invertRule(rname))
-				or mesecon:is_receptor_on (nn.name)) then
+				if (mesecon.is_conductor_on (nn, mesecon.invertRule(rname))
+				or mesecon.is_receptor_on (nn.name)) then
 					table.insert(sourcepos, np)
 				end
 			end
 		end
 	else
-		local rulenames = mesecon:rules_link_rule_all_inverted(pos, rule)
+		local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
 		for _, rname in ipairs(rulenames) do
-			local np = mesecon:addPosRule(pos, rname)
+			local np = mesecon.addPosRule(pos, rname)
 			local nn = minetest.get_node(np)
-			if (mesecon:is_conductor_on (nn, mesecon:invertRule(rname)) or mesecon:is_receptor_on (nn.name)) then
+			if (mesecon.is_conductor_on (nn, mesecon.invertRule(rname))
+			or mesecon.is_receptor_on (nn.name)) then
 				sourcepos.insert(np)
 			end
 		end
@@ -616,7 +621,7 @@ function mesecon:is_powered(pos, rule)
 end
 
 --Rules rotation Functions:
-function mesecon:rotate_rules_right(rules)
+function mesecon.rotate_rules_right(rules)
 	local nr = {}
 	for i, rule in ipairs(rules) do
 		if rule.sx then
@@ -637,7 +642,7 @@ function mesecon:rotate_rules_right(rules)
 	return nr
 end
 
-function mesecon:rotate_rules_left(rules)
+function mesecon.rotate_rules_left(rules)
 	local nr = {}
 	for i, rule in ipairs(rules) do
 		if rule.sx then
@@ -658,7 +663,7 @@ function mesecon:rotate_rules_left(rules)
 	return nr
 end
 
-function mesecon:rotate_rules_down(rules)
+function mesecon.rotate_rules_down(rules)
 	local nr = {}
 	for i, rule in ipairs(rules) do
 		if rule.sx then
@@ -679,7 +684,7 @@ function mesecon:rotate_rules_down(rules)
 	return nr
 end
 
-function mesecon:rotate_rules_up(rules)
+function mesecon.rotate_rules_up(rules)
 	local nr = {}
 	for i, rule in ipairs(rules) do
 		if rule.sx then
diff --git a/mesecons/legacy.lua b/mesecons/legacy.lua
index c4334cf..60e860f 100644
--- a/mesecons/legacy.lua
+++ b/mesecons/legacy.lua
@@ -1,32 +1,7 @@
-minetest.swap_node = minetest.swap_node or function(pos, node)

-	local data = minetest.get_meta(pos):to_table()

-	minetest.add_node(pos, node)

-	minetest.get_meta(pos):from_table(data)

+function mesecon:receptor_on(pos, rules)

+	mesecon.receptor_on(pos, rules)

 end

 

-local rules = {}

-rules.a = {x = -1, y = 0, z =  0, name="A"}

-rules.b = {x =  0, y = 0, z =  1, name="B"}

-rules.c = {x =  1, y = 0, z =  0, name="C"}

-rules.d = {x =  0, y = 0, z = -1, name="D"}

-

-function legacy_update_ports(pos)

-	local meta = minetest.get_meta(pos)

-	L = {

-		a = mesecon:is_power_on(mesecon:addPosRule(pos, rules.a),

-			mesecon:invertRule(rules.a)) and

-			mesecon:rules_link(mesecon:addPosRule(pos, rules.a), pos),

-		b = mesecon:is_power_on(mesecon:addPosRule(pos, rules.b),

-			mesecon:invertRule(rules.b)) and

-			mesecon:rules_link(mesecon:addPosRule(pos, rules.b), pos),

-		c = mesecon:is_power_on(mesecon:addPosRule(pos, rules.c),

-			mesecon:invertRule(rules.c)) and

-			mesecon:rules_link(mesecon:addPosRule(pos, rules.c), pos),

-		d = mesecon:is_power_on(mesecon:addPosRule(pos, rules.d),

-			mesecon:invertRule(rules.d)) and

-			mesecon:rules_link(mesecon:addPosRule(pos, rules.d), pos),

-	}

-	local n = (L.a and 1 or 0) + (L.b and 2 or 0) + (L.c and 4 or 0) + (L.d and 8 or 0) + 1

-	meta:set_int("real_portstates", n)

-	return L

+function mesecon:receptor_off(pos, rules)

+	mesecon.receptor_off(pos, rules)

 end

diff --git a/mesecons/presets.lua b/mesecons/presets.lua
index 53ad10d..1a6be13 100644
--- a/mesecons/presets.lua
+++ b/mesecons/presets.lua
@@ -35,11 +35,11 @@ mesecon.rules.flat =
 mesecon.rules.buttonlike_get = function(node)
 	local rules = mesecon.rules.buttonlike
 	if node.param2 == 2 then
-		rules=mesecon:rotate_rules_left(rules)
+		rules=mesecon.rotate_rules_left(rules)
 	elseif node.param2 == 3 then
-		rules=mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
+		rules=mesecon.rotate_rules_right(mesecon.rotate_rules_right(rules))
 	elseif node.param2 == 0 then
-		rules=mesecon:rotate_rules_right(rules)
+		rules=mesecon.rotate_rules_right(rules)
 	end
 	return rules
 end
diff --git a/mesecons/services.lua b/mesecons/services.lua
index 0cf94d2..97043d3 100644
--- a/mesecons/services.lua
+++ b/mesecons/services.lua
@@ -4,44 +4,44 @@ mesecon.on_placenode = function (pos, node)
 	mesecon.update_autoconnect(pos, node)
 
 	-- Receptors: Send on signal when active
-	if mesecon:is_receptor_on(node.name) then
-		mesecon:receptor_on(pos, mesecon:receptor_get_rules(node))
+	if mesecon.is_receptor_on(node.name) then
+		mesecon.receptor_on(pos, mesecon.receptor_get_rules(node))
 	end
 
 	-- Conductors: Send turnon signal when powered or replace by respective offstate conductor
 	-- if placed conductor is an onstate one
-	if mesecon:is_conductor(node.name) then
-		local sources = mesecon:is_powered(pos)
+	if mesecon.is_conductor(node.name) then
+		local sources = mesecon.is_powered(pos)
 		if sources then
 			-- also call receptor_on if itself is powered already, so that neighboring
 			-- conductors will be activated (when pushing an on-conductor with a piston)
 			for _, s in ipairs(sources) do
 				local rule = {x = pos.x - s.x, y = pos.y - s.y, z = pos.z - s.z}
-				mesecon:turnon(pos, rule)
+				mesecon.turnon(pos, rule)
 			end
-			--mesecon:receptor_on (pos, mesecon:conductor_get_rules(node))
-		elseif mesecon:is_conductor_on(node) then
-			minetest.swap_node(pos, {name = mesecon:get_conductor_off(node)})
+			--mesecon.receptor_on (pos, mesecon.conductor_get_rules(node))
+		elseif mesecon.is_conductor_on(node) then
+			minetest.swap_node(pos, {name = mesecon.get_conductor_off(node)})
 		end
 	end
 
 	-- Effectors: Send changesignal and activate or deactivate
-	if mesecon:is_effector(node.name) then
-		if mesecon:is_powered(pos) then
-			mesecon:changesignal(pos, node, mesecon:effector_get_rules(node), "on", 1)
-			mesecon:activate(pos, node, nil, 1)
+	if mesecon.is_effector(node.name) then
+		if mesecon.is_powered(pos) then
+			mesecon.changesignal(pos, node, mesecon.effector_get_rules(node), "on", 1)
+			mesecon.activate(pos, node, nil, 1)
 		else
-			mesecon:changesignal(pos, node, mesecon:effector_get_rules(node), "off", 1)
-			mesecon:deactivate(pos, node, nil, 1)
+			mesecon.changesignal(pos, node, mesecon.effector_get_rules(node), "off", 1)
+			mesecon.deactivate(pos, node, nil, 1)
 		end
 	end
 end
 
 mesecon.on_dignode = function (pos, node)
-	if mesecon:is_conductor_on(node) then
-		mesecon:receptor_off(pos, mesecon:conductor_get_rules(node))
-	elseif mesecon:is_receptor_on(node.name) then
-		mesecon:receptor_off(pos, mesecon:receptor_get_rules(node))
+	if mesecon.is_conductor_on(node) then
+		mesecon.receptor_off(pos, mesecon.conductor_get_rules(node))
+	elseif mesecon.is_receptor_on(node.name) then
+		mesecon.receptor_off(pos, mesecon.receptor_get_rules(node))
 	end
 	mesecon.queue:add_action(pos, "update_autoconnect", {node})
 end
diff --git a/mesecons/util.lua b/mesecons/util.lua
index 65172ae..281997a 100644
--- a/mesecons/util.lua
+++ b/mesecons/util.lua
@@ -1,4 +1,4 @@
-function mesecon:move_node(pos, newpos)
+function mesecon.move_node(pos, newpos)
 	local node = minetest.get_node(pos)
 	local meta = minetest.get_meta(pos):to_table()
 	minetest.remove_node(pos)
@@ -7,18 +7,18 @@ function mesecon:move_node(pos, newpos)
 end
 
 --[[ new functions:
-mesecon:flattenrules(allrules)
-mesecon:rule2bit(findrule, allrules)
-mesecon:rule2meta(findrule, allrules)
+mesecon.flattenrules(allrules)
+mesecon.rule2bit(findrule, allrules)
+mesecon.rule2meta(findrule, allrules)
 dec2bin(n)
-mesecon:getstate(nodename, states)
-mesecon:getbinstate(nodename, states)
-mesecon:get_bit(binary, bit)
-mesecon:set_bit(binary, bit, value)
-mesecon:invertRule(r)
+mesecon.getstate(nodename, states)
+mesecon.getbinstate(nodename, states)
+mesecon.get_bit(binary, bit)
+mesecon.set_bit(binary, bit, value)
+mesecon.invertRule(r)
 --]]
 
-function mesecon:flattenrules(allrules)
+function mesecon.flattenrules(allrules)
 --[[
 	{
 		{
@@ -53,7 +53,7 @@ function mesecon:flattenrules(allrules)
 --]]
 end
 
-function mesecon:rule2bit(findrule, allrules)
+function mesecon.rule2bit(findrule, allrules)
 	--get the bit of the metarule the rule is in, or bit 1
 	if (allrules[1] and
 	    allrules[1].x) or
@@ -62,14 +62,14 @@ function mesecon:rule2bit(findrule, allrules)
 	end
 	for m,metarule in ipairs( allrules) do
 	for _,    rule in ipairs(metarule ) do
-		if mesecon:cmpPos(findrule, rule) and mesecon:cmpSpecial(findrule, rule) then
+		if mesecon.cmpPos(findrule, rule) and mesecon.cmpSpecial(findrule, rule) then
 			return m
 		end
 	end
 	end
 end
 
-function mesecon:rule2metaindex(findrule, allrules)
+function mesecon.rule2metaindex(findrule, allrules)
 	--get the metarule the rule is in, or allrules
 
 	if allrules[1].x then
@@ -77,20 +77,20 @@ function mesecon:rule2metaindex(findrule, allrules)
 	end
 
 	if not(findrule) then
-		return mesecon:flattenrules(allrules)
+		return mesecon.flattenrules(allrules)
 	end
 
 	for m, metarule in ipairs( allrules) do
 	for _,     rule in ipairs(metarule ) do
-		if mesecon:cmpPos(findrule, rule) and mesecon:cmpSpecial(findrule, rule) then
+		if mesecon.cmpPos(findrule, rule) and mesecon.cmpSpecial(findrule, rule) then
 			return m
 		end
 	end
 	end
 end
 
-function mesecon:rule2meta(findrule, allrules)
-	local index = mesecon:rule2metaindex(findrule, allrules)
+function mesecon.rule2meta(findrule, allrules)
+	local index = mesecon.rule2metaindex(findrule, allrules)
 	if index == nil then
 		if allrules[1].x then
 			return allrules
@@ -119,7 +119,7 @@ else
 	end
 end
 
-function mesecon:getstate(nodename, states)
+function mesecon.getstate(nodename, states)
 	for state, name in ipairs(states) do
 		if name == nodename then
 			return state
@@ -128,23 +128,23 @@ function mesecon:getstate(nodename, states)
 	error(nodename.." doesn't mention itself in "..dump(states))
 end
 
-function mesecon:getbinstate(nodename, states)
-	return dec2bin(mesecon:getstate(nodename, states)-1)
+function mesecon.getbinstate(nodename, states)
+	return dec2bin(mesecon.getstate(nodename, states)-1)
 end
 
-function mesecon:get_bit(binary,bit)
+function mesecon.get_bit(binary,bit)
 	bit = bit or 1
 	local c = binary:len()-(bit-1)
 	return binary:sub(c,c) == "1"
 end
 
-function mesecon:set_bit(binary,bit,value)
+function mesecon.set_bit(binary,bit,value)
 	if value == "1" then
-		if not mesecon:get_bit(binary,bit) then
+		if not mesecon.get_bit(binary,bit) then
 			return dec2bin(tonumber(binary,2)+math.pow(2,bit-1))
 		end
 	elseif value == "0" then
-		if mesecon:get_bit(binary,bit) then
+		if mesecon.get_bit(binary,bit) then
 			return dec2bin(tonumber(binary,2)-math.pow(2,bit-1))
 		end
 	end
@@ -152,29 +152,29 @@ function mesecon:set_bit(binary,bit,value)
 	
 end
 
-function mesecon:invertRule(r)
+function mesecon.invertRule(r)
 	return {x = -r.x, y = -r.y, z = -r.z, sx = r.sx, sy = r.sy, sz = r.sz}
 end
 
-function mesecon:addPosRule(p, r)
+function mesecon.addPosRule(p, r)
 	return {x = p.x + r.x, y = p.y + r.y, z = p.z + r.z}
 end
 
-function mesecon:cmpPos(p1, p2)
+function mesecon.cmpPos(p1, p2)
 	return (p1.x == p2.x and p1.y == p2.y and p1.z == p2.z)
 end
 
-function mesecon:cmpSpecial(r1, r2)
+function mesecon.cmpSpecial(r1, r2)
 	return (r1.sx == r2.sx and r1.sy == r2.sy and r1.sz == r2.sz)
 end
 
-function mesecon:tablecopy(table) -- deep table copy
+function mesecon.tablecopy(table) -- deep table copy
 	if type(table) ~= "table" then return table end -- no need to copy
 	local newtable = {}
 
 	for idx, item in pairs(table) do
 		if type(item) == "table" then
-			newtable[idx] = mesecon:tablecopy(item)
+			newtable[idx] = mesecon.tablecopy(item)
 		else
 			newtable[idx] = item
 		end
@@ -183,12 +183,12 @@ function mesecon:tablecopy(table) -- deep table copy
 	return newtable
 end
 
-function mesecon:cmpAny(t1, t2)
+function mesecon.cmpAny(t1, t2)
 	if type(t1) ~= type(t2) then return false end
 	if type(t1) ~= "table" and type(t2) ~= "table" then return t1 == t2 end
 
 	for i, e in pairs(t1) do
-		if not mesecon:cmpAny(e, t2[i]) then return false end
+		if not mesecon.cmpAny(e, t2[i]) then return false end
 	end
 
 	return true
diff --git a/mesecons/wires.lua b/mesecons/wires.lua
index 158d436..8e1307e 100644
--- a/mesecons/wires.lua
+++ b/mesecons/wires.lua
@@ -18,12 +18,12 @@ local wire_getconnect = function (from_pos, self_pos)
 		if (minetest.registered_nodes[node.name].mesecon_wire) then
 			rules = mesecon.rules.default
 		else
-			rules = mesecon:get_any_inputrules(node) or {}
-			mesecon.mergetable(mesecon:get_any_outputrules(node) or {}, rules)
+			rules = mesecon.get_any_inputrules(node) or {}
+			mesecon.mergetable(mesecon.get_any_outputrules(node) or {}, rules)
 		end
 
-		for _, r in ipairs(mesecon:flattenrules(rules)) do
-			if (mesecon:cmpPos(mesecon:addPosRule(self_pos, r), from_pos)) then
+		for _, r in ipairs(mesecon.flattenrules(rules)) do
+			if (mesecon.cmpPos(mesecon.addPosRule(self_pos, r), from_pos)) then
 				return true
 			end
 		end
@@ -36,7 +36,7 @@ local wire_updateconnect = function (pos)
 	local connections = {}
 
 	for _, r in ipairs(mesecon.rules.default) do
-		if wire_getconnect(pos, mesecon:addPosRule(pos, r)) then
+		if wire_getconnect(pos, mesecon.addPosRule(pos, r)) then
 			table.insert(connections, r)
 		end
 	end
@@ -79,13 +79,13 @@ local update_on_place_dig = function (pos, node)
 	and minetest.registered_nodes[node.name].mesecon_wire then
 		rules = mesecon.rules.default
 	else
-		rules = mesecon:get_any_inputrules(node) or {}
-		mesecon.mergetable(mesecon:get_any_outputrules(node) or {}, rules)
+		rules = mesecon.get_any_inputrules(node) or {}
+		mesecon.mergetable(mesecon.get_any_outputrules(node) or {}, rules)
 	end
 	if (not rules) then return end
 
-	for _, r in ipairs(mesecon:flattenrules(rules)) do
-		local np = mesecon:addPosRule(pos, r)
+	for _, r in ipairs(mesecon.flattenrules(rules)) do
+		local np = mesecon.addPosRule(pos, r)
 		if minetest.registered_nodes[minetest.get_node(np).name]
 		and minetest.registered_nodes[minetest.get_node(np).name].mesecon_wire then
 			wire_updateconnect(np)
diff --git a/mesecons_blinkyplant/init.lua b/mesecons_blinkyplant/init.lua
index f0ab81f..5b3e471 100644
--- a/mesecons_blinkyplant/init.lua
+++ b/mesecons_blinkyplant/init.lua
@@ -64,7 +64,7 @@ minetest.register_node("mesecons_blinkyplant:blinky_plant_on", {
 	}},
 	on_rightclick = function(pos, node, clicker)
 		minetest.set_node(pos, {name = "mesecons_blinkyplant:blinky_plant"})
-		mesecon:receptor_off(pos)
+		mesecon.receptor_off(pos)
 	end
 })
 
@@ -87,10 +87,10 @@ minetest.register_abm({
 	action = function(pos, node, active_object_count, active_object_count_wider)
 		if node.name == "mesecons_blinkyplant:blinky_plant_off" then
 			minetest.add_node(pos, {name="mesecons_blinkyplant:blinky_plant_on"})
-			mesecon:receptor_on(pos)
+			mesecon.receptor_on(pos)
 		else
 			minetest.add_node(pos, {name="mesecons_blinkyplant:blinky_plant_off"})
-			mesecon:receptor_off(pos)
+			mesecon.receptor_off(pos)
 		end
 		nodeupdate(pos)	
 	end,
diff --git a/mesecons_button/init.lua b/mesecons_button/init.lua
index f4a9198..f147d8f 100644
--- a/mesecons_button/init.lua
+++ b/mesecons_button/init.lua
@@ -8,7 +8,7 @@ mesecon.button_turnoff = function (pos)
 		minetest.swap_node(pos, {name = "mesecons_button:button_off", param2=node.param2})
 		minetest.sound_play("mesecons_button_pop", {pos=pos})
 		local rules = mesecon.rules.buttonlike_get(node)
-		mesecon:receptor_off(pos, rules)
+		mesecon.receptor_off(pos, rules)
 	end
 end
 
@@ -42,7 +42,7 @@ minetest.register_node("mesecons_button:button_off", {
 	description = "Button",
 	on_punch = function (pos, node)
 		minetest.swap_node(pos, {name = "mesecons_button:button_on", param2=node.param2})
-		mesecon:receptor_on(pos, mesecon.rules.buttonlike_get(node))
+		mesecon.receptor_on(pos, mesecon.rules.buttonlike_get(node))
 		minetest.sound_play("mesecons_button_push", {pos=pos})
 		minetest.after(1, mesecon.button_turnoff, pos)
 	end,
diff --git a/mesecons_delayer/init.lua b/mesecons_delayer/init.lua
index 239d378..ba4067f 100644
--- a/mesecons_delayer/init.lua
+++ b/mesecons_delayer/init.lua
@@ -2,7 +2,7 @@
 local delayer_get_output_rules = function(node)
 	local rules = {{x = 0, y = 0, z = 1}}
 	for i = 0, node.param2 do
-		rules = mesecon:rotate_rules_left(rules)
+		rules = mesecon.rotate_rules_left(rules)
 	end
 	return rules
 end
@@ -10,7 +10,7 @@ end
 local delayer_get_input_rules = function(node)
 	local rules = {{x = 0, y = 0, z = -1}}
 	for i = 0, node.param2 do
-		rules = mesecon:rotate_rules_left(rules)
+		rules = mesecon.rotate_rules_left(rules)
 	end
 	return rules
 end
diff --git a/mesecons_detector/init.lua b/mesecons_detector/init.lua
index d7e9d41..ab997ce 100644
--- a/mesecons_detector/init.lua
+++ b/mesecons_detector/init.lua
@@ -96,7 +96,7 @@ minetest.register_abm(
 	action = function(pos)
 		if object_detector_scan(pos) then
 			minetest.swap_node(pos, {name = "mesecons_detector:object_detector_on"})
-			mesecon:receptor_on(pos, mesecon.rules.pplate)
+			mesecon.receptor_on(pos, mesecon.rules.pplate)
 		end
 	end,
 })
@@ -108,7 +108,7 @@ minetest.register_abm(
 	action = function(pos)
 		if not object_detector_scan(pos) then
 			minetest.swap_node(pos, {name = "mesecons_detector:object_detector_off"})
-			mesecon:receptor_off(pos, mesecon.rules.pplate)
+			mesecon.receptor_off(pos, mesecon.rules.pplate)
 		end
 	end,
 })
@@ -250,7 +250,7 @@ minetest.register_abm(
 	action = function(pos, node)
 		if node_detector_scan(pos) then
 			minetest.swap_node(pos, {name = "mesecons_detector:node_detector_on", param2 = node.param2})
-			mesecon:receptor_on(pos)
+			mesecon.receptor_on(pos)
 		end
 	end,
 })
@@ -262,7 +262,7 @@ minetest.register_abm(
 	action = function(pos, node)
 		if not node_detector_scan(pos) then
 			minetest.swap_node(pos, {name = "mesecons_detector:node_detector_off", param2 = node.param2})
-			mesecon:receptor_off(pos)
+			mesecon.receptor_off(pos)
 		end
 	end,
 })
diff --git a/mesecons_extrawires/corner.lua b/mesecons_extrawires/corner.lua
index d7f7a02..003275a 100644
--- a/mesecons_extrawires/corner.lua
+++ b/mesecons_extrawires/corner.lua
@@ -15,7 +15,7 @@ local corner_get_rules = function (node)
 	 {x = 0,  y = 0,  z = -1}}
 
 	for i = 0, node.param2 do
-		rules = mesecon:rotate_rules_left(rules)
+		rules = mesecon.rotate_rules_left(rules)
 	end
 
 	return rules
diff --git a/mesecons_extrawires/tjunction.lua b/mesecons_extrawires/tjunction.lua
index c5f36a2..680dc99 100644
--- a/mesecons_extrawires/tjunction.lua
+++ b/mesecons_extrawires/tjunction.lua
@@ -16,7 +16,7 @@ local tjunction_get_rules = function (node)
 	 {x = 0,  y = 0,  z = -1}}
 
 	for i = 0, node.param2 do
-		rules = mesecon:rotate_rules_left(rules)
+		rules = mesecon.rotate_rules_left(rules)
 	end
 
 	return rules
diff --git a/mesecons_extrawires/vertical.lua b/mesecons_extrawires/vertical.lua
index 0f153b7..c6bf34a 100644
--- a/mesecons_extrawires/vertical.lua
+++ b/mesecons_extrawires/vertical.lua
@@ -42,8 +42,8 @@ local vertical_updatepos = function (pos)
 	local node = minetest.get_node(pos)
 	if minetest.registered_nodes[node.name]
 	and minetest.registered_nodes[node.name].is_vertical_conductor then
-		local node_above = minetest.get_node(mesecon:addPosRule(pos, vertical_rules[1]))
-		local node_below = minetest.get_node(mesecon:addPosRule(pos, vertical_rules[2]))
+		local node_above = minetest.get_node(mesecon.addPosRule(pos, vertical_rules[1]))
+		local node_below = minetest.get_node(mesecon.addPosRule(pos, vertical_rules[2]))
 		local namestate = minetest.registered_nodes[node.name].vertical_conductor_state
 
 		local above = minetest.registered_nodes[node_above.name]
@@ -66,8 +66,8 @@ end
 
 local vertical_update = function (pos, node)
 	vertical_updatepos(pos) -- this one
-	vertical_updatepos(mesecon:addPosRule(pos, vertical_rules[1])) -- above
-	vertical_updatepos(mesecon:addPosRule(pos, vertical_rules[2])) -- below
+	vertical_updatepos(mesecon.addPosRule(pos, vertical_rules[1])) -- above
+	vertical_updatepos(mesecon.addPosRule(pos, vertical_rules[2])) -- below
 end
 
 -- Vertical wire
diff --git a/mesecons_gates/init.lua b/mesecons_gates/init.lua
index a22edf6..345c32c 100644
--- a/mesecons_gates/init.lua
+++ b/mesecons_gates/init.lua
@@ -1,6 +1,6 @@
 function gate_rotate_rules(node)
 	for rotations = 0, node.param2 - 1 do
-		rules = mesecon:rotate_rules_left(rules)
+		rules = mesecon.rotate_rules_left(rules)
 	end
 	return rules
 end
@@ -53,11 +53,11 @@ function set_gate(pos, on)
 			local node = minetest.get_node(pos)
 			if on then
 				minetest.swap_node(pos, {name = "mesecons_gates:"..gate.."_on", param2=node.param2})
-				mesecon:receptor_on(pos,
+				mesecon.receptor_on(pos,
 				gate_get_output_rules(node))
 			else
 				minetest.swap_node(pos, {name = "mesecons_gates:"..gate.."_off", param2=node.param2})
-				mesecon:receptor_off(pos,
+				mesecon.receptor_off(pos,
 				gate_get_output_rules(node))
 			end
 		end
@@ -77,7 +77,7 @@ function pop_gate(pos)
 	gate = get_gate(pos)
 	minetest.remove_node(pos)
 	minetest.after(0.2, function (pos)
-		mesecon:receptor_off(pos, mesecon.rules.flat)
+		mesecon.receptor_off(pos, mesecon.rules.flat)
 	end , pos) -- wait for pending parsings
 	minetest.add_item(pos, "mesecons_gates:"..gate.."_off")
 end
diff --git a/mesecons_hydroturbine/init.lua b/mesecons_hydroturbine/init.lua
index ef5ccae..36bd498 100644
--- a/mesecons_hydroturbine/init.lua
+++ b/mesecons_hydroturbine/init.lua
@@ -66,7 +66,7 @@ nodenames = {"mesecons_hydroturbine:hydro_turbine_off"},
 		if minetest.get_node(waterpos).name=="default:water_flowing" then
 			minetest.add_node(pos, {name="mesecons_hydroturbine:hydro_turbine_on"})
 			nodeupdate(pos)
-			mesecon:receptor_on(pos)
+			mesecon.receptor_on(pos)
 		end
 	end,
 })
@@ -80,7 +80,7 @@ nodenames = {"mesecons_hydroturbine:hydro_turbine_on"},
 		if minetest.get_node(waterpos).name~="default:water_flowing" then
 			minetest.add_node(pos, {name="mesecons_hydroturbine:hydro_turbine_off"})
 			nodeupdate(pos)
-			mesecon:receptor_off(pos)
+			mesecon.receptor_off(pos)
 		end
 	end,
 })
diff --git a/mesecons_insulated/init.lua b/mesecons_insulated/init.lua
index 26e3efb..c6fc05e 100644
--- a/mesecons_insulated/init.lua
+++ b/mesecons_insulated/init.lua
@@ -2,7 +2,7 @@ function insulated_wire_get_rules(node)
 	local rules = 	{{x = 1,  y = 0,  z = 0},
 			 {x =-1,  y = 0,  z = 0}}
 	if node.param2 == 1 or node.param2 == 3 then
-		return mesecon:rotate_rules_right(rules)
+		return mesecon.rotate_rules_right(rules)
 	end
 	return rules
 end
diff --git a/mesecons_lightstone/init.lua b/mesecons_lightstone/init.lua
index 7bb550d..5ed8f15 100644
--- a/mesecons_lightstone/init.lua
+++ b/mesecons_lightstone/init.lua
@@ -14,7 +14,7 @@ local lightstone_rules = {
 	{x=0,  y=-1, z=0},
 }
 
-function mesecon:lightstone_add(name, base_item, texture_off, texture_on)
+function mesecon.lightstone_add(name, base_item, texture_off, texture_on)
 	minetest.register_node("mesecons_lightstone:lightstone_" .. name .. "_off", {
 		tiles = {texture_off},
 		groups = {cracky=2, mesecon_effector_off = 1, mesecon = 2},
@@ -52,9 +52,9 @@ function mesecon:lightstone_add(name, base_item, texture_off, texture_on)
 end
 
 
-mesecon:lightstone_add("red", "default:clay_brick", "jeija_lightstone_red_off.png", "jeija_lightstone_red_on.png")
-mesecon:lightstone_add("green", "default:cactus", "jeija_lightstone_green_off.png", "jeija_lightstone_green_on.png")
-mesecon:lightstone_add("blue", "mesecons_materials:fiber", "jeija_lightstone_blue_off.png", "jeija_lightstone_blue_on.png")
-mesecon:lightstone_add("gray", "default:cobble", "jeija_lightstone_gray_off.png", "jeija_lightstone_gray_on.png")
-mesecon:lightstone_add("darkgray", "default:gravel", "jeija_lightstone_darkgray_off.png", "jeija_lightstone_darkgray_on.png")
-mesecon:lightstone_add("yellow", "default:mese_crystal_fragment", "jeija_lightstone_yellow_off.png", "jeija_lightstone_yellow_on.png")
+mesecon.lightstone_add("red", "default:clay_brick", "jeija_lightstone_red_off.png", "jeija_lightstone_red_on.png")
+mesecon.lightstone_add("green", "default:cactus", "jeija_lightstone_green_off.png", "jeija_lightstone_green_on.png")
+mesecon.lightstone_add("blue", "mesecons_materials:fiber", "jeija_lightstone_blue_off.png", "jeija_lightstone_blue_on.png")
+mesecon.lightstone_add("gray", "default:cobble", "jeija_lightstone_gray_off.png", "jeija_lightstone_gray_on.png")
+mesecon.lightstone_add("darkgray", "default:gravel", "jeija_lightstone_darkgray_off.png", "jeija_lightstone_darkgray_on.png")
+mesecon.lightstone_add("yellow", "default:mese_crystal_fragment", "jeija_lightstone_yellow_off.png", "jeija_lightstone_yellow_on.png")
diff --git a/mesecons_luacontroller/init.lua b/mesecons_luacontroller/init.lua
index e4faaad..0887a33 100644
--- a/mesecons_luacontroller/init.lua
+++ b/mesecons_luacontroller/init.lua
@@ -38,10 +38,6 @@ function lc_update_real_portstates(pos, rulename, newstate)
 		return
 	end
 	local n = meta:get_int("real_portstates") - 1
-	if n < 0 then
-		legacy_update_ports(pos)
-		n = meta:get_int("real_portstates") - 1
-	end
 	local L = {}
 	for i = 1, 4 do
 		L[i] = n%2
@@ -63,9 +59,6 @@ local get_real_portstates = function(pos) -- determine if ports are powered (by
 	local meta = minetest.get_meta(pos)
 	local L = {}
 	local n = meta:get_int("real_portstates") - 1
-	if n < 0 then
-		return legacy_update_ports(pos)
-	end
 	for _, index in ipairs({"a", "b", "c", "d"}) do
 		L[index] = ((n%2) == 1)
 		n = math.floor(n/2)
@@ -92,9 +85,9 @@ end
 
 local setport = function (pos, rule, state)
 	if state then
-		mesecon:receptor_on(pos, {rule})
+		mesecon.receptor_on(pos, {rule})
 	else
-		mesecon:receptor_off(pos, {rule})
+		mesecon.receptor_off(pos, {rule})
 	end
 end
 
@@ -122,7 +115,7 @@ end
 --------------------
 
 local overheat_off = function(pos)
-	mesecon:receptor_off(pos, mesecon.rules.flat)
+	mesecon.receptor_off(pos, mesecon.rules.flat)
 end
 
 -------------------
@@ -484,7 +477,7 @@ minetest.register_node(nodename, {
 				c = c == 1, -- controller powers itself
 				d = d == 1},-- so those that light up
 	after_dig_node = function (pos, node)
-		mesecon:receptor_off(pos, output_rules)
+		mesecon.receptor_off(pos, output_rules)
 	end,
 	is_luacontroller = true,
 })
diff --git a/mesecons_microcontroller/init.lua b/mesecons_microcontroller/init.lua
index 9883b85..7e290a3 100644
--- a/mesecons_microcontroller/init.lua
+++ b/mesecons_microcontroller/init.lua
@@ -134,7 +134,7 @@ minetest.register_node(nodename, {
 	mesecons = mesecons,
 	after_dig_node = function (pos, node)
 		rules = microc_rules[node.name]
-		mesecon:receptor_off(pos, rules)
+		mesecon.receptor_off(pos, rules)
 	end,
 })
 end
@@ -166,7 +166,7 @@ function update_yc(pos)
 	if (mesecon.do_overheat(pos)) then
 		minetest.remove_node(pos)
 		minetest.after(0.2, function (pos)
-			mesecon:receptor_off(pos, mesecon.rules.flat)
+			mesecon.receptor_off(pos, mesecon.rules.flat)
 		end , pos) -- wait for pending parsings
 		minetest.add_item(pos, "mesecons_microcontroller:microcontroller0000")
 	end
@@ -185,7 +185,7 @@ end
 
 --Code Parsing
 function yc_code_remove_commentary(code)
-	is_string = false
+	local is_string = false
 	for i = 1, #code do
 		if code:sub(i, i) == '"' then
 			is_string = not is_string --toggle is_string
@@ -205,15 +205,17 @@ function yc_parsecode(code, pos)
 	local c
 	local eeprom = meta:get_string("eeprom")
 	while true do
+		local command, params
 		command, endi = parse_get_command(code, endi)
 		if command == nil then return nil end
 		if command == true then break end --end of code
 		if command == "if" then
+			local r
 			r, endi = yc_command_if(code, endi, yc_merge_portstates(Lreal, Lvirtual), eeprom)
 			if r == nil then return nil end
 			if r == true then  -- nothing
 			elseif r == false then
-				endi_new = yc_skip_to_else (code, endi)
+				local endi_new = yc_skip_to_else (code, endi)
 				if endi_new == nil then --else > not found
 					endi = yc_skip_to_endif(code, endi)
 				else
@@ -223,7 +225,7 @@ function yc_parsecode(code, pos)
 			end
 		else
 			params, endi = parse_get_params(code, endi)
-			if params  == nil then return nil end
+			if not params then return nil end
 		end
 		if command == "on" then
 			L = yc_command_on (params, Lvirtual)
@@ -236,6 +238,7 @@ function yc_parsecode(code, pos)
 			local su = yc_command_after(params, pos)
 			if su == nil then return nil end
 		elseif command == "sbi" then
+			local new_eeprom
 			new_eeprom, Lvirtual = yc_command_sbi (params, eeprom, yc_merge_portstates(Lreal, Lvirtual), Lvirtual)
 			if new_eeprom == nil then return nil
 			else eeprom = new_eeprom end
@@ -253,7 +256,7 @@ end
 
 function parse_get_command(code, starti)
 	i = starti
-	s = nil
+	local s
 	while s ~= "" do
 		s = string.sub(code, i, i)
 		if s == "(" then
@@ -279,7 +282,7 @@ end
 
 function parse_get_params(code, starti)
 	i = starti
-	s = nil
+	local s
 	local params = {}
 	local is_string = false
 	while s ~= "" do
@@ -302,7 +305,7 @@ end
 
 function yc_parse_get_eeprom_param(cond, starti)
 	i = starti
-	s = nil
+	local s
 	local addr
 	while s ~= "" do
 		s = string.sub(cond, i, i)
@@ -405,7 +408,7 @@ function yc_command_sbi(params, eeprom, L, Lv)
 	end
 
 	--is an eeprom address
-	new_eeprom = "";
+	local new_eeprom = "";
 	for i=1, #eeprom do
 		if tonumber(params[1])==i then 
 			new_eeprom = new_eeprom..status
@@ -459,17 +462,17 @@ function yc_command_if(code, starti, L, eeprom)
 
 	cond = yc_command_parsecondition(cond, L, eeprom)
 
+	local result
 	if cond == "0" then result = false
-	elseif cond == "1" then result = true
-	else result = nil end
-	if result == nil then end
+	elseif cond == "1" then result = true end
+	if not result then end
 	return result, endi --endi from local cond, endi = yc_command_if_getcondition(code, starti)
 end
 
 --Condition parsing
 function yc_command_if_getcondition(code, starti)
 	i = starti
-	s = nil
+	local s
 	local brackets = 1 --1 Bracket to close
 	while s ~= "" do
 		s = string.sub(code, i, i)
@@ -503,8 +506,8 @@ function yc_command_parsecondition(cond, L, eeprom)
 	while i<=l do
 		local s = cond:sub(i,i)
 		if s == "#" then
-			addr, endi = yc_parse_get_eeprom_param(cond, i+1)
-			buf = yc_eeprom_read(tonumber(addr), eeprom)
+			local addr, endi = yc_parse_get_eeprom_param(cond, i+1)
+			local buf = yc_eeprom_read(tonumber(addr), eeprom)
 			if buf == nil then return nil end
 			local call = cond:sub(i, endi-1)
 			cond = string.gsub(cond, call, buf)
@@ -578,10 +581,8 @@ end
 
 --Virtual-Hardware functions
 function yc_eeprom_read(number, eeprom)
-	if number == nil then return nil, nil end
-	value = eeprom:sub(number, number)
-	if value  == nil then return nil, nil end
-	return value, endi
+	if not number then return end
+	return eeprom:sub(number, number)
 end
 
 --Real I/O functions
@@ -603,23 +604,23 @@ function yc_action_setports(pos, L, Lv)
 	local rules
 	if Lv.a ~= L.a then
 		rules = microc_rules[name.."0001"]
-		if L.a == true then mesecon:receptor_on(pos, rules)
-		else mesecon:receptor_off(pos, rules) end
+		if L.a == true then mesecon.receptor_on(pos, rules)
+		else mesecon.receptor_off(pos, rules) end
 	end
 	if Lv.b ~= L.b then
 		rules = microc_rules[name.."0010"]
-		if L.b == true then mesecon:receptor_on(pos, rules)
-		else mesecon:receptor_off(pos, rules) end
+		if L.b == true then mesecon.receptor_on(pos, rules)
+		else mesecon.receptor_off(pos, rules) end
 	end
 	if Lv.c ~= L.c then 
 		rules = microc_rules[name.."0100"]
-		if L.c == true then mesecon:receptor_on(pos, rules)
-		else mesecon:receptor_off(pos, rules) end
+		if L.c == true then mesecon.receptor_on(pos, rules)
+		else mesecon.receptor_off(pos, rules) end
 	end
 	if Lv.d ~= L.d then 
 		rules = microc_rules[name.."1000"]
-		if L.d == true then mesecon:receptor_on(pos, rules)
-		else mesecon:receptor_off(pos, rules) end
+		if L.d == true then mesecon.receptor_on(pos, rules)
+		else mesecon.receptor_off(pos, rules) end
 	end
 end
 
@@ -639,10 +640,6 @@ function yc_update_real_portstates(pos, node, rulename, newstate)
 		return
 	end
 	local n = meta:get_int("real_portstates") - 1
-	if n < 0 then
-		legacy_update_ports(pos)
-		n = meta:get_int("real_portstates") - 1
-	end
 	local L = {}
 	for i = 1, 4 do
 		L[i] = n%2
@@ -664,9 +661,6 @@ function yc_get_real_portstates(pos) -- determine if ports are powered (by itsel
 	local meta = minetest.get_meta(pos)
 	local L = {}
 	local n = meta:get_int("real_portstates") - 1
-	if n < 0 then
-		return legacy_update_ports(pos)
-	end
 	for _, index in ipairs({"a", "b", "c", "d"}) do
 		L[index] = ((n%2) == 1)
 		n = math.floor(n/2)
@@ -675,12 +669,12 @@ function yc_get_real_portstates(pos) -- determine if ports are powered (by itsel
 end
 
 function yc_get_virtual_portstates(pos) -- portstates according to the name
-	name = minetest.get_node(pos).name
-	b, a = string.find(name, ":microcontroller")
+	local name = minetest.get_node(pos).name
+	local b, a = string.find(name, ":microcontroller")
 	if a == nil then return nil end
 	a = a + 1
 
-	Lvirtual = {a=false, b=false, c=false, d=false}
+	local Lvirtual = {a=false, b=false, c=false, d=false}
 	if name:sub(a  , a  ) == "1" then Lvirtual.d = true end
 	if name:sub(a+1, a+1) == "1" then Lvirtual.c = true end
 	if name:sub(a+2, a+2) == "1" then Lvirtual.b = true end
diff --git a/mesecons_movestones/init.lua b/mesecons_movestones/init.lua
index e8c52cb..96d417a 100644
--- a/mesecons_movestones/init.lua
+++ b/mesecons_movestones/init.lua
@@ -8,7 +8,7 @@
 -- Pushes all block in front of it
 -- Pull all blocks in its back
 
-function mesecon:get_movestone_direction(pos)
+function mesecon.get_movestone_direction(pos)
 	getactivated = 0
 	local lpos
 	local getactivated = 0
@@ -28,28 +28,28 @@ function mesecon:get_movestone_direction(pos)
 
 	lpos = {x=pos.x+1, y=pos.y, z=pos.z}
 	for n = 1, 3 do
-		if mesecon:is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
+		if mesecon.is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
 			return {x=0, y=0, z=-1}
 		end
 	end
 
 	lpos = {x = pos.x-1, y = pos.y, z = pos.z}
 	for n=4, 6 do
-		if mesecon:is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
+		if mesecon.is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
 			return {x=0, y=0, z=1}
 		end
 	end
 
 	lpos = {x = pos.x, y = pos.y, z = pos.z+1}
 	for n=7, 9 do
-		if mesecon:is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
+		if mesecon.is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
 			return {x=-1, y=0, z=0}
 		end
 	end
 
 	lpos = {x = pos.x, y = pos.y, z = pos.z-1}
 	for n=10, 12 do
-		if mesecon:is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
+		if mesecon.is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
 			return {x=1, y=0, z=0}
 		end
 	end
@@ -64,7 +64,7 @@ minetest.register_node("mesecons_movestones:movestone", {
 	sounds = default.node_sound_stone_defaults(),
 	mesecons = {effector = {
 		action_on = function (pos, node)
-			local direction=mesecon:get_movestone_direction(pos)
+			local direction=mesecon.get_movestone_direction(pos)
 			if not direction then return end
 			minetest.remove_node(pos)
 			mesecon.update_autoconnect(pos)
@@ -89,7 +89,7 @@ minetest.register_entity("mesecons_movestones:movestone_entity", {
 	on_step = function(self, dtime)
 		local pos = self.object:getpos()
 		pos.x, pos.y, pos.z = math.floor(pos.x+0.5), math.floor(pos.y+0.5), math.floor(pos.z+0.5)
-		local direction = mesecon:get_movestone_direction(pos)
+		local direction = mesecon.get_movestone_direction(pos)
 
 		if not direction then -- no mesecon power
 			--push only solid nodes
@@ -97,7 +97,7 @@ minetest.register_entity("mesecons_movestones:movestone_entity", {
 			if  name ~= "air" and name ~= "ignore"
 			and ((not minetest.registered_nodes[name])
 			or minetest.registered_nodes[name].liquidtype == "none") then
-				mesecon:mvps_push(pos, self.lastdir, MOVESTONE_MAXIMUM_PUSH)
+				mesecon.mvps_push(pos, self.lastdir, MOVESTONE_MAXIMUM_PUSH)
 			end
 			minetest.add_node(pos, {name="mesecons_movestones:movestone"})
 			self.object:remove()
@@ -105,14 +105,14 @@ minetest.register_entity("mesecons_movestones:movestone_entity", {
 		end
 
 		local success, stack, oldstack =
-			mesecon:mvps_push(pos, direction, MOVESTONE_MAXIMUM_PUSH)
+			mesecon.mvps_push(pos, direction, MOVESTONE_MAXIMUM_PUSH)
 		if not success then -- Too large stack/stopper in the way
 			minetest.add_node(pos, {name="mesecons_movestones:movestone"})
 			self.object:remove()
 			return
 		else
-			mesecon:mvps_process_stack (stack)
-			mesecon:mvps_move_objects  (pos, direction, oldstack)
+			mesecon.mvps_process_stack (stack)
+			mesecon.mvps_move_objects  (pos, direction, oldstack)
 			self.lastdir = direction
 		end
 
@@ -143,7 +143,7 @@ minetest.register_node("mesecons_movestones:sticky_movestone", {
 	sounds = default.node_sound_stone_defaults(),
 	mesecons = {effector = {
 		action_on = function (pos, node)
-			local direction=mesecon:get_movestone_direction(pos)
+			local direction=mesecon.get_movestone_direction(pos)
 			if not direction then return end
 			minetest.remove_node(pos)
 			mesecon.update_autoconnect(pos)
@@ -175,7 +175,7 @@ minetest.register_entity("mesecons_movestones:sticky_movestone_entity", {
 	on_step = function(self, dtime)
 		local pos = self.object:getpos()
 		pos.x, pos.y, pos.z = math.floor(pos.x+0.5), math.floor(pos.y+0.5), math.floor(pos.z+0.5)
-		local direction = mesecon:get_movestone_direction(pos)
+		local direction = mesecon.get_movestone_direction(pos)
 
 		if not direction then -- no mesecon power
 			--push only solid nodes
@@ -183,9 +183,9 @@ minetest.register_entity("mesecons_movestones:sticky_movestone_entity", {
 			if  name ~= "air" and name ~= "ignore"
 			and ((not minetest.registered_nodes[name])
 			or minetest.registered_nodes[name].liquidtype == "none") then
-				mesecon:mvps_push(pos, self.lastdir, MOVESTONE_MAXIMUM_PUSH)
+				mesecon.mvps_push(pos, self.lastdir, MOVESTONE_MAXIMUM_PUSH)
 				--STICKY
-				mesecon:mvps_pull_all(pos, self.lastdir)
+				mesecon.mvps_pull_all(pos, self.lastdir)
 			end
 			minetest.add_node(pos, {name="mesecons_movestones:sticky_movestone"})
 			self.object:remove()
@@ -193,24 +193,24 @@ minetest.register_entity("mesecons_movestones:sticky_movestone_entity", {
 		end
 
 		local success, stack, oldstack =
-			mesecon:mvps_push(pos, direction, MOVESTONE_MAXIMUM_PUSH)
+			mesecon.mvps_push(pos, direction, MOVESTONE_MAXIMUM_PUSH)
 		if not success then -- Too large stack/stopper in the way
 			minetest.add_node(pos, {name="mesecons_movestones:sticky_movestone"})
 			self.object:remove()
 			return
 		else
-			mesecon:mvps_process_stack (stack)
-			mesecon:mvps_move_objects  (pos, direction, oldstack)
+			mesecon.mvps_process_stack (stack)
+			mesecon.mvps_move_objects  (pos, direction, oldstack)
 			self.lastdir = direction
 		end
 
 		self.object:setvelocity({x=direction.x*2, y=direction.y*2, z=direction.z*2})
 
 		--STICKY
-		mesecon:mvps_pull_all(pos, direction)
+		mesecon.mvps_pull_all(pos, direction)
 	end,
 })
 
 
-mesecon:register_mvps_unmov("mesecons_movestones:movestone_entity")
-mesecon:register_mvps_unmov("mesecons_movestones:sticky_movestone_entity")
+mesecon.register_mvps_unmov("mesecons_movestones:movestone_entity")
+mesecon.register_mvps_unmov("mesecons_movestones:sticky_movestone_entity")
diff --git a/mesecons_mvps/init.lua b/mesecons_mvps/init.lua
index a9c0da8..163ad28 100644
--- a/mesecons_mvps/init.lua
+++ b/mesecons_mvps/init.lua
@@ -4,7 +4,7 @@ mesecon.mvps_stoppers = {}
 mesecon.mvps_unmov = {}
 mesecon.on_mvps_move = {}
 
-function mesecon:is_mvps_stopper(node, pushdir, stack, stackid)
+function mesecon.is_mvps_stopper(node, pushdir, stack, stackid)
 	local get_stopper = mesecon.mvps_stoppers[node.name]
 	if type (get_stopper) == "function" then
 		get_stopper = get_stopper(node, pushdir, stack, stackid)
@@ -12,7 +12,7 @@ function mesecon:is_mvps_stopper(node, pushdir, stack, stackid)
 	return get_stopper
 end
 
-function mesecon:register_mvps_stopper(nodename, get_stopper)
+function mesecon.register_mvps_stopper(nodename, get_stopper)
 	if get_stopper == nil then
 			get_stopper = true
 	end
@@ -20,16 +20,16 @@ function mesecon:register_mvps_stopper(nodename, get_stopper)
 end
 
 -- Objects that cannot be moved (e.g. movestones)
-function mesecon:register_mvps_unmov(objectname)
+function mesecon.register_mvps_unmov(objectname)
 	mesecon.mvps_unmov[objectname] = true;
 end
 
-function mesecon:is_mvps_unmov(objectname)
+function mesecon.is_mvps_unmov(objectname)
 	return mesecon.mvps_unmov[objectname]
 end
 
 -- Functions to be called on mvps movement
-function mesecon:register_on_mvps_move(callback)
+function mesecon.register_on_mvps_move(callback)
 	mesecon.on_mvps_move[#mesecon.on_mvps_move+1] = callback
 end
 
@@ -39,14 +39,14 @@ local function on_mvps_move(moved_nodes)
 	end
 end
 
-function mesecon:mvps_process_stack(stack)
+function mesecon.mvps_process_stack(stack)
 	-- update mesecons for placed nodes ( has to be done after all nodes have been added )
 	for _, n in ipairs(stack) do
 		mesecon.on_placenode(n.pos, minetest.get_node(n.pos))
 	end
 end
 
-function mesecon:mvps_get_stack(pos, dir, maximum)
+function mesecon.mvps_get_stack(pos, dir, maximum)
 	-- determine the number of nodes to be pushed
 	local np = {x = pos.x, y = pos.y, z = pos.z}
 	local nodes = {}
@@ -65,18 +65,18 @@ function mesecon:mvps_get_stack(pos, dir, maximum)
 
 		table.insert (nodes, {node = nn, pos = np})
 
-		np = mesecon:addPosRule(np, dir)
+		np = mesecon.addPosRule(np, dir)
 	end
 	return nodes
 end
 
-function mesecon:mvps_push(pos, dir, maximum) -- pos: pos of mvps; dir: direction of push; maximum: maximum nodes to be pushed
-	local nodes = mesecon:mvps_get_stack(pos, dir, maximum)
+function mesecon.mvps_push(pos, dir, maximum) -- pos: pos of mvps; dir: direction of push; maximum: maximum nodes to be pushed
+	local nodes = mesecon.mvps_get_stack(pos, dir, maximum)
 
 	if not nodes then return end
 	-- determine if one of the nodes blocks the push
 	for id, n in ipairs(nodes) do
-		if mesecon:is_mvps_stopper(n.node, dir, nodes, id) then
+		if mesecon.is_mvps_stopper(n.node, dir, nodes, id) then
 			return
 		end
 	end
@@ -94,17 +94,17 @@ function mesecon:mvps_push(pos, dir, maximum) -- pos: pos of mvps; dir: directio
 
 	-- add nodes
 	for _, n in ipairs(nodes) do
-		np = mesecon:addPosRule(n.pos, dir)
+		np = mesecon.addPosRule(n.pos, dir)
 		minetest.add_node(np, n.node)
 		minetest.get_meta(np):from_table(n.meta)
 	end
 	
 	local moved_nodes = {}
-	local oldstack = mesecon:tablecopy(nodes)
+	local oldstack = mesecon.tablecopy(nodes)
 	for i in ipairs(nodes) do
 		moved_nodes[i] = {}
 		moved_nodes[i].oldpos = nodes[i].pos
-		nodes[i].pos = mesecon:addPosRule(nodes[i].pos, dir)
+		nodes[i].pos = mesecon.addPosRule(nodes[i].pos, dir)
 		moved_nodes[i].pos = nodes[i].pos
 		moved_nodes[i].node = nodes[i].node
 		moved_nodes[i].meta = nodes[i].meta
@@ -115,20 +115,20 @@ function mesecon:mvps_push(pos, dir, maximum) -- pos: pos of mvps; dir: directio
 	return true, nodes, oldstack
 end
 
-mesecon:register_on_mvps_move(function(moved_nodes)
+mesecon.register_on_mvps_move(function(moved_nodes)
 	for _, n in ipairs(moved_nodes) do
 		mesecon.on_placenode(n.pos, n.node)
 		mesecon.update_autoconnect(n.pos)
 	end
 end)
 
-function mesecon:mvps_pull_single(pos, dir) -- pos: pos of mvps; direction: direction of pull (matches push direction for sticky pistons)
-	np = mesecon:addPosRule(pos, dir)
+function mesecon.mvps_pull_single(pos, dir) -- pos: pos of mvps; direction: direction of pull (matches push direction for sticky pistons)
+	np = mesecon.addPosRule(pos, dir)
 	nn = minetest.get_node(np)
 
 	if ((not minetest.registered_nodes[nn.name]) --unregistered node
 	or minetest.registered_nodes[nn.name].liquidtype == "none") --non-liquid node
-	and not mesecon:is_mvps_stopper(nn, {x = -dir.x, y = -dir.y, z = -dir.z}, {{pos = np, node = nn}}, 1) then --non-stopper node
+	and not mesecon.is_mvps_stopper(nn, {x = -dir.x, y = -dir.y, z = -dir.z}, {{pos = np, node = nn}}, 1) then --non-stopper node
 		local meta = minetest.get_meta(np):to_table()
 		minetest.remove_node(np)
 		minetest.add_node(pos, nn)
@@ -143,7 +143,7 @@ function mesecon:mvps_pull_single(pos, dir) -- pos: pos of mvps; direction: dire
 	return {{pos = np, node = {param2 = 0, name = "air"}}, {pos = pos, node = nn}}
 end
 
-function mesecon:mvps_pull_all(pos, direction) -- pos: pos of mvps; direction: direction of pull
+function mesecon.mvps_pull_all(pos, direction) -- pos: pos of mvps; direction: direction of pull
 	local lpos = {x=pos.x-direction.x, y=pos.y-direction.y, z=pos.z-direction.z} -- 1 away
 	local lnode = minetest.get_node(lpos)
 	local lpos2 = {x=pos.x-direction.x*2, y=pos.y-direction.y*2, z=pos.z-direction.z*2} -- 2 away
@@ -189,11 +189,11 @@ function mesecon:mvps_pull_all(pos, direction) -- pos: pos of mvps; direction: d
 	on_mvps_move(moved_nodes)
 end
 
-function mesecon:mvps_move_objects(pos, dir, nodestack)
+function mesecon.mvps_move_objects(pos, dir, nodestack)
 	local objects_to_move = {}
 
 	-- Move object at tip of stack
-	local pushpos = mesecon:addPosRule(pos, -- get pos at tip of stack
+	local pushpos = mesecon.addPosRule(pos, -- get pos at tip of stack
 		{x = dir.x * #nodestack,
 		 y = dir.y * #nodestack,
 		 z = dir.z * #nodestack})
@@ -208,7 +208,7 @@ function mesecon:mvps_move_objects(pos, dir, nodestack)
 	if tonumber(minetest.setting_get("movement_gravity")) > 0 and dir.y == 0 then
 		-- If gravity positive and dir horizontal, push players standing on the stack
 		for _, n in ipairs(nodestack) do
-			local p_above = mesecon:addPosRule(n.pos, {x=0, y=1, z=0})
+			local p_above = mesecon.addPosRule(n.pos, {x=0, y=1, z=0})
 			local objects = minetest.get_objects_inside_radius(p_above, 1)
 			for _, obj in ipairs(objects) do
 				table.insert(objects_to_move, obj)
@@ -218,8 +218,8 @@ function mesecon:mvps_move_objects(pos, dir, nodestack)
 
 	for _, obj in ipairs(objects_to_move) do
 		local entity = obj:get_luaentity()
-		if not entity or not mesecon:is_mvps_unmov(entity.name) then
-			local np = mesecon:addPosRule(obj:getpos(), dir)
+		if not entity or not mesecon.is_mvps_unmov(entity.name) then
+			local np = mesecon.addPosRule(obj:getpos(), dir)
 
 			--move only if destination is not solid
 			local nn = minetest.get_node(np)
@@ -231,5 +231,5 @@ function mesecon:mvps_move_objects(pos, dir, nodestack)
 	end
 end
 
-mesecon:register_mvps_stopper("default:chest_locked")
-mesecon:register_mvps_stopper("default:furnace")
+mesecon.register_mvps_stopper("default:chest_locked")
+mesecon.register_mvps_stopper("default:furnace")
diff --git a/mesecons_pistons/init.lua b/mesecons_pistons/init.lua
index efc18f3..ee7c228 100644
--- a/mesecons_pistons/init.lua
+++ b/mesecons_pistons/init.lua
@@ -33,7 +33,7 @@ local piston_down_rules =
 local piston_get_rules = function (node)
 	local rules = piston_rules
 	for i = 1, node.param2 do
-		rules = mesecon:rotate_rules_left(rules)
+		rules = mesecon.rotate_rules_left(rules)
 	end
 	return rules
 end
@@ -41,7 +41,7 @@ end
 piston_facedir_direction = function (node)
 	local rules = {{x = 0, y = 0, z = -1}}
 	for i = 1, node.param2 do
-		rules = mesecon:rotate_rules_left(rules)
+		rules = mesecon.rotate_rules_left(rules)
 	end
 	return rules[1]
 end
@@ -57,7 +57,7 @@ end
 local piston_remove_pusher = function(pos, node)
 	pistonspec = minetest.registered_nodes[node.name].mesecons_piston
 	dir = piston_get_direction(pistonspec.dir, node)
-	local pusherpos = mesecon:addPosRule(pos, dir)
+	local pusherpos = mesecon.addPosRule(pos, dir)
 	local pushername = minetest.get_node(pusherpos).name
 
 	-- make sure there actually is a pusher (for compatibility reasons mainly)
@@ -78,8 +78,8 @@ local piston_on = function(pos, node)
 	local pistonspec = minetest.registered_nodes[node.name].mesecons_piston
 
 	local dir = piston_get_direction(pistonspec.dir, node)
-	local np = mesecon:addPosRule(pos, dir)
-	local success, stack, oldstack = mesecon:mvps_push(np, dir, PISTON_MAXIMUM_PUSH)
+	local np = mesecon.addPosRule(pos, dir)
+	local success, stack, oldstack = mesecon.mvps_push(np, dir, PISTON_MAXIMUM_PUSH)
 	if success then
 		minetest.add_node(pos, {param2 = node.param2, name = pistonspec.onname})
 		minetest.add_node(np,  {param2 = node.param2, name = pistonspec.pusher})
@@ -88,8 +88,8 @@ local piston_on = function(pos, node)
 			max_hear_distance = 20,
 			gain = 0.3,
 		})
-		mesecon:mvps_process_stack (stack)
-		mesecon:mvps_move_objects  (np, dir, oldstack)
+		mesecon.mvps_process_stack (stack)
+		mesecon.mvps_move_objects  (np, dir, oldstack)
 	end
 end
 
@@ -100,9 +100,9 @@ local piston_off = function(pos, node)
 
 	if pistonspec.sticky then
 		dir = piston_get_direction(pistonspec.dir, node)
-		pullpos = mesecon:addPosRule(pos, dir)
-		stack = mesecon:mvps_pull_single(pullpos, dir)
-		mesecon:mvps_process_stack(pos, dir, stack)
+		pullpos = mesecon.addPosRule(pos, dir)
+		stack = mesecon.mvps_pull_single(pullpos, dir)
+		mesecon.mvps_process_stack(pos, dir, stack)
 	end
 end
 
@@ -693,14 +693,14 @@ local piston_pusher_up_down_get_stopper = function (node, dir, stack, stackid)
 	return true
 end
 
-mesecon:register_mvps_stopper("mesecons_pistons:piston_pusher_normal", piston_pusher_get_stopper)
-mesecon:register_mvps_stopper("mesecons_pistons:piston_pusher_sticky", piston_pusher_get_stopper)
+mesecon.register_mvps_stopper("mesecons_pistons:piston_pusher_normal", piston_pusher_get_stopper)
+mesecon.register_mvps_stopper("mesecons_pistons:piston_pusher_sticky", piston_pusher_get_stopper)
 
-mesecon:register_mvps_stopper("mesecons_pistons:piston_up_pusher_normal", piston_pusher_up_down_get_stopper)
-mesecon:register_mvps_stopper("mesecons_pistons:piston_up_pusher_sticky", piston_pusher_up_down_get_stopper)
+mesecon.register_mvps_stopper("mesecons_pistons:piston_up_pusher_normal", piston_pusher_up_down_get_stopper)
+mesecon.register_mvps_stopper("mesecons_pistons:piston_up_pusher_sticky", piston_pusher_up_down_get_stopper)
 
-mesecon:register_mvps_stopper("mesecons_pistons:piston_down_pusher_normal", piston_pusher_up_down_get_stopper)
-mesecon:register_mvps_stopper("mesecons_pistons:piston_down_pusher_sticky", piston_pusher_up_down_get_stopper)
+mesecon.register_mvps_stopper("mesecons_pistons:piston_down_pusher_normal", piston_pusher_up_down_get_stopper)
+mesecon.register_mvps_stopper("mesecons_pistons:piston_down_pusher_sticky", piston_pusher_up_down_get_stopper)
 
 
 -- Register pistons as stoppers if they would be seperated from the stopper
@@ -717,12 +717,12 @@ end
 local piston_get_stopper = function (node, dir, stack, stackid)
 	pistonspec = minetest.registered_nodes[node.name].mesecons_piston
 	dir = piston_get_direction(pistonspec.dir, node)
-	local pusherpos  = mesecon:addPosRule(stack[stackid].pos, dir)
+	local pusherpos  = mesecon.addPosRule(stack[stackid].pos, dir)
 	local pushernode = minetest.get_node(pusherpos)
 
 	if minetest.registered_nodes[node.name].mesecons_piston.pusher == pushernode.name then
 		for _, s in ipairs(stack) do
-			if  mesecon:cmpPos(s.pos, pusherpos) -- pusher is also to be pushed
+			if  mesecon.cmpPos(s.pos, pusherpos) -- pusher is also to be pushed
 			and s.node.param2 == node.param2 then
 				return false
 			end
@@ -731,14 +731,14 @@ local piston_get_stopper = function (node, dir, stack, stackid)
 	return true
 end
 
-mesecon:register_mvps_stopper("mesecons_pistons:piston_normal_on", piston_get_stopper)
-mesecon:register_mvps_stopper("mesecons_pistons:piston_sticky_on", piston_get_stopper)
+mesecon.register_mvps_stopper("mesecons_pistons:piston_normal_on", piston_get_stopper)
+mesecon.register_mvps_stopper("mesecons_pistons:piston_sticky_on", piston_get_stopper)
 
-mesecon:register_mvps_stopper("mesecons_pistons:piston_up_normal_on", piston_up_down_get_stopper)
-mesecon:register_mvps_stopper("mesecons_pistons:piston_up_sticky_on", piston_up_down_get_stopper)
+mesecon.register_mvps_stopper("mesecons_pistons:piston_up_normal_on", piston_up_down_get_stopper)
+mesecon.register_mvps_stopper("mesecons_pistons:piston_up_sticky_on", piston_up_down_get_stopper)
 
-mesecon:register_mvps_stopper("mesecons_pistons:piston_down_normal_on", piston_up_down_get_stopper)
-mesecon:register_mvps_stopper("mesecons_pistons:piston_down_sticky_on", piston_up_down_get_stopper)
+mesecon.register_mvps_stopper("mesecons_pistons:piston_down_normal_on", piston_up_down_get_stopper)
+mesecon.register_mvps_stopper("mesecons_pistons:piston_down_sticky_on", piston_up_down_get_stopper)
 
 --craft recipes
 minetest.register_craft({
diff --git a/mesecons_pressureplates/init.lua b/mesecons_pressureplates/init.lua
index 788dd95..e9fdf7f 100644
--- a/mesecons_pressureplates/init.lua
+++ b/mesecons_pressureplates/init.lua
@@ -17,23 +17,23 @@ pp_on_timer = function (pos, elapsed)
 	if not basename then return end
 
 	local objs   = minetest.get_objects_inside_radius(pos, 1)
-	local two_below = mesecon:addPosRule(pos, {x = 0, y = -2, z = 0})
+	local two_below = mesecon.addPosRule(pos, {x = 0, y = -2, z = 0})
 
 	if objs[1] == nil and node.name == basename .. "_on" then
 		minetest.add_node(pos, {name = basename .. "_off"})
-		mesecon:receptor_off(pos, mesecon.rules.pplate)
+		mesecon.receptor_off(pos, mesecon.rules.pplate)
 		-- force deactivation of mesecon two blocks below (hacky)
-		if not mesecon:connected_to_receptor(two_below) then
-			mesecon:turnoff(two_below)
+		if not mesecon.connected_to_receptor(two_below) then
+			mesecon.turnoff(two_below)
 		end
 	else
 		for k, obj in pairs(objs) do
 			local objpos = obj:getpos()
 			if objpos.y > pos.y-1 and objpos.y < pos.y then
 				minetest.add_node(pos, {name = basename .. "_on"})
-				mesecon:receptor_on(pos, mesecon.rules.pplate )
+				mesecon.receptor_on(pos, mesecon.rules.pplate )
 				-- force activation of mesecon two blocks below (hacky)
-				mesecon:turnon(two_below)
+				mesecon.turnon(two_below)
 			end
 		end
 	end
@@ -49,7 +49,7 @@ end
 -- image:	inventory and wield image of the pressure plate
 -- recipe:	crafting recipe of the pressure plate
 
-function mesecon:register_pressure_plate(basename, description, textures_off, textures_on, image_w, image_i, recipe)
+function mesecon.register_pressure_plate(basename, description, textures_off, textures_on, image_w, image_i, recipe)
 	mesecon.register_node(basename, {
 		drawtype = "nodebox",
 		inventory_image = image_i,
@@ -81,7 +81,7 @@ function mesecon:register_pressure_plate(basename, description, textures_off, te
 	})
 end
 
-mesecon:register_pressure_plate(
+mesecon.register_pressure_plate(
 	"mesecons_pressureplates:pressure_plate_wood",
 	"Wooden Pressure Plate",
 	{"jeija_pressure_plate_wood_off.png","jeija_pressure_plate_wood_off.png","jeija_pressure_plate_wood_off_edges.png"},
@@ -90,7 +90,7 @@ mesecon:register_pressure_plate(
 	"jeija_pressure_plate_wood_inv.png",
 	{{"group:wood", "group:wood"}})
 
-mesecon:register_pressure_plate(
+mesecon.register_pressure_plate(
 	"mesecons_pressureplates:pressure_plate_stone",
 	"Stone Pressure Plate",
 	{"jeija_pressure_plate_stone_off.png","jeija_pressure_plate_stone_off.png","jeija_pressure_plate_stone_off_edges.png"},
diff --git a/mesecons_random/init.lua b/mesecons_random/init.lua
index 670bea4..0136309 100644
--- a/mesecons_random/init.lua
+++ b/mesecons_random/init.lua
@@ -9,7 +9,7 @@ minetest.register_node("mesecons_random:removestone", {
 	mesecons = {effector = {
 		action_on = function (pos, node)
 			minetest.remove_node(pos)
-			mesecon:update_autoconnect(pos)
+			mesecon.update_autoconnect(pos)
 		end
 	}}
 })
diff --git a/mesecons_receiver/init.lua b/mesecons_receiver/init.lua
index b368f24..c2d973e 100644
--- a/mesecons_receiver/init.lua
+++ b/mesecons_receiver/init.lua
@@ -9,11 +9,11 @@ local receiver_get_rules = function (node)
 	local rules = {	{x =  1, y = 0, z = 0},
 			{x = -2, y = 0, z = 0}}
 	if node.param2 == 2 then
-		rules = mesecon:rotate_rules_left(rules)
+		rules = mesecon.rotate_rules_left(rules)
 	elseif node.param2 == 3 then
-		rules = mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
+		rules = mesecon.rotate_rules_right(mesecon.rotate_rules_right(rules))
 	elseif node.param2 == 0 then
-		rules = mesecon:rotate_rules_right(rules)
+		rules = mesecon.rotate_rules_right(rules)
 	end
 	return rules
 end
@@ -81,15 +81,15 @@ minetest.register_node("mesecons_receiver:receiver_off", {
 	}}
 })
 
-function mesecon:receiver_get_pos_from_rcpt(pos, param2)
+function mesecon.receiver_get_pos_from_rcpt(pos, param2)
 	local rules = {{x = 2,  y = 0, z = 0}}
 	if param2 == nil then param2 = minetest.get_node(pos).param2 end
 	if param2 == 2 then
-		rules = mesecon:rotate_rules_left(rules)
+		rules = mesecon.rotate_rules_left(rules)
 	elseif param2 == 3 then
-		rules = mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
+		rules = mesecon.rotate_rules_right(mesecon.rotate_rules_right(rules))
 	elseif param2 == 0 then
-		rules = mesecon:rotate_rules_right(rules)
+		rules = mesecon.rotate_rules_right(rules)
 	end
 	np = {
 	x = pos.x + rules[1].x,
@@ -98,16 +98,16 @@ function mesecon:receiver_get_pos_from_rcpt(pos, param2)
 	return np
 end
 
-function mesecon:receiver_place(rcpt_pos)
+function mesecon.receiver_place(rcpt_pos)
 	local node = minetest.get_node(rcpt_pos)
-	local pos = mesecon:receiver_get_pos_from_rcpt(rcpt_pos, node.param2)
+	local pos = mesecon.receiver_get_pos_from_rcpt(rcpt_pos, node.param2)
 	local nn = minetest.get_node(pos)
 
 	if string.find(nn.name, "mesecons:wire_") ~= nil then
 		minetest.dig_node(pos)
-		if mesecon:is_power_on(rcpt_pos) then
+		if mesecon.is_power_on(rcpt_pos) then
 			minetest.add_node(pos, {name = "mesecons_receiver:receiver_on", param2 = node.param2})
-			mesecon:receptor_on(pos, receiver_get_rules(node))
+			mesecon.receptor_on(pos, receiver_get_rules(node))
 		else
 			minetest.add_node(pos, {name = "mesecons_receiver:receiver_off", param2 = node.param2})
 		end
@@ -115,8 +115,8 @@ function mesecon:receiver_place(rcpt_pos)
 	end
 end
 
-function mesecon:receiver_remove(rcpt_pos, dugnode)
-	local pos = mesecon:receiver_get_pos_from_rcpt(rcpt_pos, dugnode.param2)
+function mesecon.receiver_remove(rcpt_pos, dugnode)
+	local pos = mesecon.receiver_get_pos_from_rcpt(rcpt_pos, dugnode.param2)
 	local nn = minetest.get_node(pos)
 	if string.find(nn.name, "mesecons_receiver:receiver_") ~=nil then
 		minetest.dig_node(pos)
@@ -129,13 +129,13 @@ end
 
 minetest.register_on_placenode(function (pos, node)
 	if minetest.get_item_group(node.name, "mesecon_needs_receiver") == 1 then
-		mesecon:receiver_place(pos)
+		mesecon.receiver_place(pos)
 	end
 end)
 
 minetest.register_on_dignode(function(pos, node)
 	if minetest.get_item_group(node.name, "mesecon_needs_receiver") == 1 then
-		mesecon:receiver_remove(pos, node)
+		mesecon.receiver_remove(pos, node)
 	end
 end)
 
@@ -152,7 +152,7 @@ minetest.register_on_placenode(function (pos, node)
 			y = pos.y + rules[i].y,
 			z = pos.z + rules[i].z}
 			if minetest.get_item_group(minetest.get_node(np).name, "mesecon_needs_receiver") == 1 then
-				mesecon:receiver_place(np)
+				mesecon.receiver_place(np)
 			end
 			i = i + 1
 		end
diff --git a/mesecons_solarpanel/init.lua b/mesecons_solarpanel/init.lua
index c30fe12..bc5a408 100644
--- a/mesecons_solarpanel/init.lua
+++ b/mesecons_solarpanel/init.lua
@@ -75,7 +75,7 @@ minetest.register_abm(
 
 		if light >= 12 then
 			minetest.set_node(pos, {name="mesecons_solarpanel:solar_panel_on", param2=node.param2})
-			mesecon:receptor_on(pos)
+			mesecon.receptor_on(pos)
 		end
 	end,
 })
@@ -89,7 +89,7 @@ minetest.register_abm(
 
 		if light < 12 then
 			minetest.set_node(pos, {name="mesecons_solarpanel:solar_panel_off", param2=node.param2})
-			mesecon:receptor_off(pos)
+			mesecon.receptor_off(pos)
 		end
 	end,
 })
diff --git a/mesecons_switch/init.lua b/mesecons_switch/init.lua
index 1b7f478..f40ef80 100644
--- a/mesecons_switch/init.lua
+++ b/mesecons_switch/init.lua
@@ -11,7 +11,7 @@ minetest.register_node("mesecons_switch:mesecon_switch_off", {
 	}},
 	on_punch = function(pos, node)
 		minetest.swap_node(pos, {name = "mesecons_switch:mesecon_switch_on", param2 = node.param2})
-		mesecon:receptor_on(pos)
+		mesecon.receptor_on(pos)
 		minetest.sound_play("mesecons_switch", {pos=pos})
 	end
 })
@@ -27,7 +27,7 @@ minetest.register_node("mesecons_switch:mesecon_switch_on", {
 	}},
 	on_punch = function(pos, node)
 		minetest.swap_node(pos, {name = "mesecons_switch:mesecon_switch_off", param2 = node.param2})
-		mesecon:receptor_off(pos)
+		mesecon.receptor_off(pos)
 		minetest.sound_play("mesecons_switch", {pos=pos})
 	end
 })
diff --git a/mesecons_torch/init.lua b/mesecons_torch/init.lua
index 97a2991..91f8e65 100644
--- a/mesecons_torch/init.lua
+++ b/mesecons_torch/init.lua
@@ -2,15 +2,15 @@
 
 local rotate_torch_rules = function (rules, param2)
 	if param2 == 5 then
-		return mesecon:rotate_rules_right(rules)
+		return mesecon.rotate_rules_right(rules)
 	elseif param2 == 2 then
-		return mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules)) --180 degrees
+		return mesecon.rotate_rules_right(mesecon.rotate_rules_right(rules)) --180 degrees
 	elseif param2 == 4 then
-		return mesecon:rotate_rules_left(rules)
+		return mesecon.rotate_rules_left(rules)
 	elseif param2 == 1 then
-		return mesecon:rotate_rules_down(rules)
+		return mesecon.rotate_rules_down(rules)
 	elseif param2 == 0 then
-		return mesecon:rotate_rules_up(rules)
+		return mesecon.rotate_rules_up(rules)
 	else
 		return rules
 	end
@@ -91,8 +91,8 @@ minetest.register_abm({
 	action = function(pos, node)
 		local is_powered = false
 		for _, rule in ipairs(torch_get_input_rules(node)) do
-			local src = mesecon:addPosRule(pos, rule)
-			if mesecon:is_power_on(src) then
+			local src = mesecon.addPosRule(pos, rule)
+			if mesecon.is_power_on(src) then
 				is_powered = true
 			end
 		end
@@ -100,11 +100,11 @@ minetest.register_abm({
 		if is_powered then
 			if node.name == "mesecons_torch:mesecon_torch_on" then
 				minetest.swap_node(pos, {name = "mesecons_torch:mesecon_torch_off", param2 = node.param2})
-				mesecon:receptor_off(pos, torch_get_output_rules(node))
+				mesecon.receptor_off(pos, torch_get_output_rules(node))
 			end
 		elseif node.name == "mesecons_torch:mesecon_torch_off" then
 			minetest.swap_node(pos, {name = "mesecons_torch:mesecon_torch_on", param2 = node.param2})
-			mesecon:receptor_on(pos, torch_get_output_rules(node))
+			mesecon.receptor_on(pos, torch_get_output_rules(node))
 		end
 	end
 })
diff --git a/mesecons_walllever/init.lua b/mesecons_walllever/init.lua
index a35d9f1..89ca88d 100644
--- a/mesecons_walllever/init.lua
+++ b/mesecons_walllever/init.lua
@@ -33,7 +33,7 @@ minetest.register_node("mesecons_walllever:wall_lever_off", {
 	description="Lever",
 	on_punch = function (pos, node)
 		minetest.swap_node(pos, {name = "mesecons_walllever:wall_lever_on", param2 = node.param2})
-		mesecon:receptor_on(pos, mesecon.rules.buttonlike_get(node))
+		mesecon.receptor_on(pos, mesecon.rules.buttonlike_get(node))
 		minetest.sound_play("mesecons_lever", {pos=pos})
 	end,
 	sounds = default.node_sound_wood_defaults(),
@@ -75,7 +75,7 @@ minetest.register_node("mesecons_walllever:wall_lever_on", {
 	description="Lever",
 	on_punch = function (pos, node)
 		minetest.swap_node(pos, {name = "mesecons_walllever:wall_lever_off", param2 = node.param2})
-		mesecon:receptor_off(pos, mesecon.rules.buttonlike_get(node))
+		mesecon.receptor_off(pos, mesecon.rules.buttonlike_get(node))
 		minetest.sound_play("mesecons_lever", {pos=pos})
 	end,
 	sounds = default.node_sound_wood_defaults(),