Better mesecon-enabled doors

The mesecons_compatibility doors erred in making steel doors, which
are meant to be locked, openable by anyone using a mesecon signal.
They also didn't handle mirror-paired doors, and nastily duplicated
lots of the standard door code rather than using it and adding to it.
Replace mesecons_compatibility with a new system, in which standard
doors are left alone and new types of door are added that have mesecon
behaviour.  The new door types are each available in both wood and steel,
using the standard door textures.

The mesecon-operated doors open and close according to the mesecon
signal they receive: open when the signal is on and closed when off.
Unlike the old mesecons_compatibility doors, which only accepted the
signal to the bottom half, these accept the signal to either half of
the door.  A convenient kind of control therefore is a wall-mounted
button just above the doorway: the signal flows diagonally down to the
top half of the door.  The door cannot be operated manually.

The mesecon-signalling doors are opened and closed manually, and generate
a mesecon signal indicating whether they're open, on when open and off
when closed.  Thus opening the door can trigger automatic activity.
Pairing a mesecon-signalling door with a mesecon-operated door results
in a door pair where right-clicking on one door operates both.

By making use of the pairing behaviour built into the standard doors mod,
which is inherited by the mesecon doors, and placing doors from sideways
angles, it is possible to effectively get mesecon doors with the opposite
signal sense.  For example, a mesecon-signalling door that sends an on
signal when closed, turning the signal off when opened.

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),
 				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
@@ -44,8 +44,7 @@ end
 -- However, even that does not work in some cases, that's why we delay the time the globalsteps
 -- start to be execute by 5 seconds
 local get_highest_priority = function (actions)
-	local highestp = -1
-	local highesti
+	local highestp = -1, highesti
 	for i, ac in ipairs(actions) do
 		if ac.priority > highestp then
 			highestp = ac.priority
@@ -57,13 +56,10 @@ local get_highest_priority = function (actions)
 end
 
 local m_time = 0
-local resumetime = mesecon.setting("resumetime", 4)
 minetest.register_globalstep(function (dtime)
 	m_time = m_time + dtime
-	-- don't even try if server has not been running for XY seconds; resumetime = time to wait
-	-- after starting the server before processing the ActionQueue, don't set this too low
-	if (m_time < resumetime) then return end
-	local actions = mesecon.tablecopy(mesecon.queue.actions)
+	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_now={}
 
 	mesecon.queue.actions = {}

mesecons/init.lua

@@ -47,14 +47,15 @@ mesecon.queue.funcs={} -- contains all ActionQueue functions
 -- Settings
 dofile(minetest.get_modpath("mesecons").."/settings.lua")
 
+-- Presets (eg default rules)
+dofile(minetest.get_modpath("mesecons").."/presets.lua");
+
+
 -- Utilities like comparing positions,
 -- adding positions and rules,
 -- mostly things that make the source look cleaner
 dofile(minetest.get_modpath("mesecons").."/util.lua");
 
--- Presets (eg default rules)
-dofile(minetest.get_modpath("mesecons").."/presets.lua");
-
 -- The ActionQueue
 -- Saves all the actions that have to be execute in the future
 dofile(minetest.get_modpath("mesecons").."/actionqueue.lua");
@@ -66,6 +67,11 @@ dofile(minetest.get_modpath("mesecons").."/actionqueue.lua");
 -- like calling action_on/off/change
 dofile(minetest.get_modpath("mesecons").."/internal.lua");
 
+-- Deprecated stuff
+-- To be removed in future releases
+-- Currently there is nothing here
+dofile(minetest.get_modpath("mesecons").."/legacy.lua");
+
 -- API
 -- these are the only functions you need to remember
 
@@ -73,8 +79,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)
@@ -83,16 +89,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
 
@@ -100,38 +106,34 @@ 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
 
 
 print("[OK] Mesecons")
 
--- Deprecated stuff
--- To be removed in future releases
-dofile(minetest.get_modpath("mesecons").."/legacy.lua");
-
 --The actual wires
 dofile(minetest.get_modpath("mesecons").."/wires.lua");
 

mesecons/internal.lua

@@ -1,58 +1,62 @@
 -- Internal.lua - The core of mesecons
 --
--- For more practical developer resources see http://mesecons.net/developers.php
+-- 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, recdepth)		--> Activates   the effector node at the specific pos (calls nodedef.mesecons.effector.action_on), higher recdepths are executed later
+-- mesecon:deactivate(pos, node, recdepth)		--> Deactivates the effector node at the specific pos (calls nodedef.mesecons.effector.action_off), "
+-- mesecon:changesignal(pos, node, rulename, newstate)	--> Changes     the effector node at the specific pos (calls nodedef.mesecons.effector.action_change), "
+
+-- RULES
+-- mesecon:add_rules(name, rules) | deprecated? --> Saves rules table by name
+-- mesecon:get_rules(name, rules) | deprecated? --> Loads rules table with name
 
 -- 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, link) 				--> link is the input rule that caused calling turnon, turns on every connected node, iterative
--- mesecon.turnoff(pos, link)				--> link is the input rule that caused calling turnoff, turns off every connected node, iterative
--- mesecon.connected_to_receptor(pos, link)		--> Returns true if pos is connected to a receptor directly or via conductors, iterative
--- 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 helpers
--- mesecon.rotate_rules_right(rules)
--- mesecon.rotate_rules_left(rules)
--- mesecon.rotate_rules_up(rules)
--- mesecon.rotate_rules_down(rules)
+-- RULES ROTATION helpsers
+-- 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 +64,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 +72,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,55 +80,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
-end
-
-function mesecon.get_any_rules (node)
-	return mesecon.mergetable(mesecon.get_any_inputrules(node) or {},
-		mesecon.get_any_outputrules(node) or {})
+	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
@@ -139,32 +140,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
@@ -182,150 +183,159 @@ end
 
 -- Activation:
 mesecon.queue:add_function("activate", function (pos, rulename)
-	local node = minetest.get_node(pos)
-	local effector = mesecon.get_effector(node.name)
+	node = minetest.get_node(pos)
+	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, recdepth)
 	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, recdepth + 1)
 		end
 		return
 	end
-	mesecon.queue:add_action(pos, "activate", {rulename}, nil, rulename, 1 / depth)
+	mesecon.queue:add_action(pos, "activate", {rulename}, nil, rulename, 1 / recdepth)
 end
 
 
 -- Deactivation
 mesecon.queue:add_function("deactivate", function (pos, rulename)
-	local node = minetest.get_node(pos)
-	local effector = mesecon.get_effector(node.name)
+	node = minetest.get_node(pos)
+	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, recdepth)
 	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, recdepth + 1)
 		end
 		return
 	end
-	mesecon.queue:add_action(pos, "deactivate", {rulename}, nil, rulename, 1 / depth)
+	mesecon.queue:add_action(pos, "deactivate", {rulename}, nil, rulename, 1 / recdepth)
 end
 
 
 -- Change
 mesecon.queue:add_function("change", function (pos, rulename, changetype)
-	local node = minetest.get_node(pos)
-	local effector = mesecon.get_effector(node.name)
+	node = minetest.get_node(pos)
+	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, recdepth)
 	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, recdepth + 1)
 		end
 		return
 	end
 
-	-- Include "change" in overwritecheck so that it cannot be overwritten
-	-- by "active" / "deactivate" that will be called upon the node at the same time.
-	local overwritecheck = {"change", rulename}
-	mesecon.queue:add_action(pos, "change", {rulename, newstate}, nil, overwritecheck, 1 / depth)
+	mesecon.queue:add_action(pos, "change", {rulename, newstate}, nil, rulename, 1 / recdepth)
+end
+
+-- #########
+-- # Rules # "Database" for rulenames
+-- #########
+
+function mesecon:add_rules(name, rules)
+	mesecon.rules[name] = rules
+end
+
+function mesecon:get_rules(name)
+	return mesecon.rules[name]
 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
@@ -339,127 +349,126 @@ 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)
-	local frontiers = {{pos = pos, link = link}}
+function mesecon:turnon(pos, rulename, recdepth)
+	recdepth = recdepth or 2
+	local node = minetest.get_node(pos)
 
-	local depth = 1
-	while frontiers[depth] do
-		local f = frontiers[depth]
-		local node = minetest.get_node_or_nil(f.pos)
+	if(node.name == "ignore") then
+		-- try turning on later again
+		mesecon.queue:add_action(
+			pos, "turnon", {rulename, recdepth + 1}, nil, true)
+	end
+	
+	if mesecon:is_conductor_off(node, rulename) then
+		local rules = mesecon:conductor_get_rules(node)
 
-		-- area not loaded, postpone action
-		if not node then
-			mesecon.queue:add_action(f.pos, "turnon", {link}, nil, true)
-		elseif 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),
-				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)
-
-				-- 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)
-					for _, l in ipairs(links) do
-						table.insert(frontiers, {pos = np, link = l})
-					end
+		if not rulename then
+			for _, rule in ipairs(mesecon:flattenrules(rules)) do
+				if mesecon:connected_to_receptor(pos, rule) then
+					mesecon:turnon(pos, rule, recdepth + 1)
 				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)
+			return
+		end
+
+		minetest.swap_node(pos, {name = mesecon:get_conductor_on(node, rulename), param2 = node.param2})
+
+		for _, rule in ipairs(mesecon:rule2meta(rulename, rules)) do
+			local np = mesecon:addPosRule(pos, rule)
+			if(minetest.get_node(np).name == "ignore") then
+				-- try turning on later again
+				mesecon.queue:add_action(
+					np, "turnon", {rulename, recdepth + 1}, nil, true)
+			else
+				local rulenames = mesecon:rules_link_rule_all(pos, rule)
+
+				for _, rulename in ipairs(rulenames) do
+					mesecon:turnon(np, rulename, recdepth + 1)
+				end
 			end
 		end
-		depth = depth + 1
+	elseif mesecon:is_effector(node.name) then
+		mesecon:changesignal(pos, node, rulename, mesecon.state.on, recdepth)
+		if mesecon:is_effector_off(node.name) then
+			mesecon:activate(pos, node, rulename, recdepth)
+		end
 	end
 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)
-	local frontiers = {{pos = pos, link = link}}
+function mesecon:turnoff(pos, rulename, recdepth)
+	recdepth = recdepth or 2
+	local node = minetest.get_node(pos)
 
-	local depth = 1
-	while frontiers[depth] do
-		local f = frontiers[depth]
-		local node = minetest.get_node_or_nil(f.pos)
+	if(node.name == "ignore") then
+		-- try turning on later again
+		mesecon.queue:add_action(
+			pos, "turnoff", {rulename, recdepth + 1}, nil, true)
+	end
 
-		-- area not loaded, postpone action
-		if not node then
-			mesecon.queue:add_action(f.pos, "turnoff", {link}, nil, true)
-		elseif mesecon.is_conductor_on(node, f.link) then
-			local rules = mesecon.conductor_get_rules(node)
+	if mesecon:is_conductor_on(node, rulename) then
+		local rules = mesecon:conductor_get_rules(node)
+		minetest.swap_node(pos, {name = mesecon:get_conductor_off(node, rulename), param2 = node.param2})
 
-			minetest.swap_node(f.pos, {name = mesecon.get_conductor_off(node, f.link),
-				param2 = node.param2})
+		for _, rule in ipairs(mesecon:rule2meta(rulename, rules)) do
+			local np = mesecon:addPosRule(pos, rule)
+			if(minetest.get_node(np).name == "ignore") then
+				-- try turning on later again
+				mesecon.queue:add_action(
+					np, "turnoff", {rulename, recdepth + 1}, nil, true)
+			else
+				local rulenames = mesecon:rules_link_rule_all(pos, rule)
 
-			-- call turnoff on neighbors: normal rules
-			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)
-					for _, l in ipairs(links) do
-						table.insert(frontiers, {pos = np, link = l})
-					end
+				for _, rulename in ipairs(rulenames) do
+					mesecon:turnoff(np, rulename, recdepth + 1)
 				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)
-			end
 		end
-		depth = depth + 1
+	elseif mesecon:is_effector(node.name) then
+		mesecon:changesignal(pos, node, rulename, mesecon.state.off, recdepth)
+		if mesecon:is_effector_on(node.name)
+		and not mesecon:is_powered(pos) then
+			mesecon:deactivate(pos, node, rulename, recdepth + 1)
+		end
 	end
 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, link)
+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(link, rules)) do
-		local links = mesecon.rules_link_rule_all_inverted(pos, rule)
-		for _, l in ipairs(links) do
-			local np = mesecon.addPosRule(pos, l)
-			if mesecon.find_receptor_on(np, mesecon.invertRule(l)) then
+	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
 				return true
 			end
 		end
@@ -468,56 +477,66 @@ function mesecon.connected_to_receptor(pos, link)
 	return false
 end
 
-function mesecon.find_receptor_on(pos, link)
-	local frontiers = {{pos = pos, link = link}}
-	local checked = {}
+function mesecon:find_receptor_on(pos, checked, rulename)
+	local node = minetest.get_node(pos)
 
-	-- List of positions that have been searched for onstate receptors
-	local depth = 1
-	while frontiers[depth] do
-		local f = frontiers[depth]
-		local node = minetest.get_node_or_nil(f.pos)
+	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 not node then return false end
-		if mesecon.is_receptor_on(node.name) then return true end
-		if mesecon.is_conductor_on(node, f.link) then
-			local rules = mesecon.conductor_get_rules(node)
-
-			-- call turnoff on neighbors: normal rules
-			for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
-				local np = mesecon.addPosRule(f.pos, r)
-
-				local links = mesecon.rules_link_rule_all_inverted(f.pos, r)
-				for _, l in ipairs(links) do
-					local checkedstring = np.x..np.y..np.z..l.x..l.y..l.z
-					if not checked[checkedstring] then
-						table.insert(frontiers, {pos = np, link = l})
-						checked[checkedstring] = true
-					end
+	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
+				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 _, rname in ipairs(rulenames) do
+				local np = mesecon:addPosRule(pos, rname)
+				if mesecon:find_receptor_on(np, checked, mesecon:invertRule(rname)) then
+					return true
 				end
 			end
-			
 		end
-		depth = depth + 1
+	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
+				return false, checked
+			end
+		end
+		table.insert(checked, {x=pos.x, y=pos.y, z=pos.z})
 	end
+
+	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
-					return true, inputrule
+				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
 			end
 		end
@@ -525,128 +544,161 @@ 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) --output/input are positions (outputrules optional, used if node has been dug), second return value: affected input rules
+	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
-			table.insert(rules, inputrule)
+		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
 	end
 	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
-			table.insert(rules, 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
-					table.insert(sourcepos, np)
+				if (mesecon:is_conductor_on (nn, mesecon:invertRule(rname)) or mesecon:is_receptor_on (nn.name)) then
+					return true
 				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
-				table.insert(sourcepos, np)
+			if (mesecon:is_conductor_on (nn, mesecon:invertRule(rname)) or mesecon:is_receptor_on (nn.name)) then
+				return true
 			end
 		end
 	end
-
-	-- Return FALSE if not powered, return list of sources if is powered
-	if (#sourcepos == 0) then return false
-	else return sourcepos end
+	
+	return false
 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
-		table.insert(nr, {
-			x = -rule.z, 
-			y =  rule.y, 
-			z =  rule.x,
-			name = rule.name})
+		if rule.sx then
+			table.insert(nr, {
+				x = -rule.z, 
+				y =  rule.y, 
+				z =  rule.x,
+				sx = -rule.sz, 
+				sy =  rule.sy, 
+				sz =  rule.sx})
+		else
+			table.insert(nr, {
+				x = -rule.z, 
+				y =  rule.y, 
+				z =  rule.x})
+		end
 	end
 	return nr
 end
 
-function mesecon.rotate_rules_left(rules)
+function mesecon:rotate_rules_left(rules)
 	local nr = {}
 	for i, rule in ipairs(rules) do
-		table.insert(nr, {
-			x =  rule.z, 
-			y =  rule.y, 
-			z = -rule.x,
-			name = rule.name})
+		if rule.sx then
+			table.insert(nr, {
+				x =  rule.z, 
+				y =  rule.y, 
+				z = -rule.x,
+				sx =  rule.sz, 
+				sy =  rule.sy, 
+				sz = -rule.sx})
+		else
+			table.insert(nr, {
+				x =  rule.z, 
+				y =  rule.y, 
+				z = -rule.x})
+		end
 	end
 	return nr
 end
 
-function mesecon.rotate_rules_down(rules)
+function mesecon:rotate_rules_down(rules)
 	local nr = {}
 	for i, rule in ipairs(rules) do
-		table.insert(nr, {
-			x = -rule.y, 
-			y =  rule.x, 
-			z =  rule.z,
-			name = rule.name})
+		if rule.sx then
+			table.insert(nr, {
+				x = -rule.y, 
+				y =  rule.x, 
+				z =  rule.z,
+				sx = -rule.sy, 
+				sy =  rule.sx, 
+				sz =  rule.sz})
+		else
+			table.insert(nr, {
+				x = -rule.y, 
+				y =  rule.x, 
+				z =  rule.z})
+		end
 	end
 	return nr
 end
 
-function mesecon.rotate_rules_up(rules)
+function mesecon:rotate_rules_up(rules)
 	local nr = {}
 	for i, rule in ipairs(rules) do
-		table.insert(nr, {
-			x =  rule.y, 
-			y = -rule.x, 
-			z =  rule.z,
-			name = rule.name})
+		if rule.sx then
+			table.insert(nr, {
+				x =  rule.y, 
+				y = -rule.x, 
+				z =  rule.z,
+				sx =  rule.sy, 
+				sy = -rule.sx, 
+				sz =  rule.sz})
+		else
+			table.insert(nr, {
+				x =  rule.y, 
+				y = -rule.x, 
+				z =  rule.z})
+		end
 	end
 	return nr
 end

mesecons/legacy.lua

@@ -1,30 +1,32 @@
--- Ugly hack to prevent breaking compatibility with other mods
--- Just remove the following two functions to delete the hack, to be done when other mods have updated
-function mesecon.receptor_on(self, pos, rules)
-	if (self.receptor_on) then
-		print("[Mesecons] Warning: A mod with mesecon support called mesecon:receptor_on.")
-		print("[Mesecons]          If you are the programmer of this mod, please update it ")
-		print("[Mesecons]          to use mesecon.receptor_on instead. mesecon:* is deprecated")
-		print("[Mesecons]          Otherwise, please make sure you're running the latest version")
-		print("[Mesecons]          of that mod and inform the mod creator.")
-	else
-		rules = pos
-		pos = self
-	end
-	mesecon.queue:add_action(pos, "receptor_on", {rules}, nil, rules)
-end
-
-function mesecon.receptor_off(self, pos, rules)
-	if (self.receptor_off) then
-		print("[Mesecons] Warning: A mod with mesecon support called mesecon:receptor_off.")
-		print("[Mesecons]          If you are the programmer of this mod, please update it ")
-		print("[Mesecons]          to use mesecon.receptor_off instead. mesecon:* is deprecated")
-		print("[Mesecons]          Otherwise, please make sure you're running the latest version")
-		print("[Mesecons]          of that mod and inform the mod creator.")
-	else
-		rules = pos
-		pos = self
-	end
-	mesecon.queue:add_action(pos, "receptor_off", {rules}, nil, rules)
-end
-
+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)
+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
+end

mesecons/presets.lua

@@ -15,8 +15,6 @@ mesecon.rules.default =
  {x=0,  y=1,  z=-1},
  {x=0,  y=-1, z=-1}}
 
-mesecon.rules.pplate = mesecon.mergetable(mesecon.rules.default, {{x=0, y=-2, z=0}})
-
 mesecon.rules.buttonlike =
 {{x = 1,  y = 0, z = 0},
  {x = 1,  y = 1, z = 0},
@@ -34,11 +32,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

mesecons/services.lua

@@ -1,62 +1,44 @@
 -- Dig and place services
 
 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 sources then
+	if mesecon:is_conductor(node.name) then
+		if mesecon:is_powered(pos) 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)
-			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:turnon (pos)
+			mesecon:receptor_on (pos, mesecon:conductor_get_rules(node))
+		elseif mesecon:is_conductor_off(node.name) 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
-		local powered_rules = {}
-
-		-- for each input rule, check if powered
-		for _, r in ipairs(mesecon.effector_get_rules(node)) do
-			local powered = mesecon.is_powered(pos, r)
-			if powered then table.insert(powered_rules, r) end
-
-			local state = powered and mesecon.state.on or mesecon.state.off
-			mesecon.changesignal(pos, node, r, state, 1)
-		end
-
-		if (#powered_rules > 0) then
-			for _, r in ipairs(powered_rules) do
-				mesecon.activate(pos, node, r, 1)
-			end
+	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)
 		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
 
-mesecon.queue:add_function("update_autoconnect", mesecon.update_autoconnect)
-
 minetest.register_on_placenode(mesecon.on_placenode)
 minetest.register_on_dignode(mesecon.on_dignode)
 
@@ -70,7 +52,7 @@ mesecon.do_overheat = function(pos)
 	heat = heat + 1
 	meta:set_int("heat", heat)
 
-	if heat < mesecon.setting("overheat_max", 20) then
+	if heat < OVERHEAT_MAX then
 		mesecon.queue:add_action(pos, "cooldown", {}, 1, nil, 0)
 	else
 		return true

mesecons/settings.lua

@@ -1,10 +1,12 @@
 -- SETTINGS
-function mesecon.setting(setting, default)
-	if type(default) == "bool" then
-		return minetest.setting_getbool("mesecon."..setting) or default
-	elseif type(default) == "string" then
-		return minetest.setting_get("mesecon."..setting) or default
-	elseif type(default) == "number" then
-		return tonumber(minetest.setting_get("mesecon."..setting) or default)
-	end
-end
+BLINKY_PLANT_INTERVAL = 3
+NEW_STYLE_WIRES  = true  	-- true = new nodebox wires, false = old raillike wires
+PRESSURE_PLATE_INTERVAL = 0.1
+OBJECT_DETECTOR_RADIUS = 6
+PISTON_MAXIMUM_PUSH = 15
+MOVESTONE_MAXIMUM_PUSH = 100
+MESECONS_RESUMETIME = 4		-- time to wait when starting the server before
+				-- processing the ActionQueue, don't set this too low
+OVERHEAT_MAX = 20		-- maximum heat of any component that directly sends an output
+				-- signal when the input changes (e.g. luacontroller, gates)
+				-- Unit: actions per second, checks are every 1 second

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)
@@ -6,7 +6,19 @@ function mesecon.move_node(pos, newpos)
 	minetest.get_meta(pos):from_table(meta)
 end
 
-function mesecon.flattenrules(allrules)
+--[[ new functions:
+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)
+--]]
+
+function mesecon:flattenrules(allrules)
 --[[
 	{
 		{
@@ -41,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
@@ -50,36 +62,35 @@ function mesecon.rule2bit(findrule, allrules)
 	end
 	for m,metarule in ipairs( allrules) do
 	for _,    rule in ipairs(metarule ) do
-		if mesecon.cmpPos(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
 		return nil
 	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) then
+		if mesecon:cmpPos(findrule, rule) and mesecon:cmpSpecial(findrule, rule) then
 			return m
 		end
 	end
 	end
 end
 
-function mesecon.rule2meta(findrule, allrules)
-	if #allrules == 0 then return {} end
-
-	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
@@ -90,16 +101,25 @@ function mesecon.rule2meta(findrule, allrules)
 	return allrules[index]
 end
 
-function mesecon.dec2bin(n)
-	local x, y = math.floor(n / 2), n % 2
-	if (n > 1) then
-		return mesecon.dec2bin(x)..y
-	else
-		return ""..y
+if convert_base then
+	print(
+		"base2dec is tonumber(num,base1)\n"..
+		"commonlib needs dec2base(num,base2)\n"..
+		"and it needs base2base(num,base1,base2),\n"..
+		"which is dec2base(tonumber(num,base1),base2)"
+	)
+else
+	function dec2bin(n)
+		local x, y = math.floor(n / 2), n % 2
+		if (n > 1) then
+			return dec2bin(x)..y
+		else
+			return ""..y
+		end
 	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
@@ -108,49 +128,53 @@ function mesecon.getstate(nodename, states)
 	error(nodename.." doesn't mention itself in "..dump(states))
 end
 
-function mesecon.getbinstate(nodename, states)
-	return mesecon.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
-			return mesecon.dec2bin(tonumber(binary,2)+math.pow(2,bit-1))
+		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
-			return mesecon.dec2bin(tonumber(binary,2)-math.pow(2,bit-1))
+		if mesecon:get_bit(binary,bit) then
+			return dec2bin(tonumber(binary,2)-math.pow(2,bit-1))
 		end
 	end
 	return binary
 	
 end
 
-function mesecon.invertRule(r)
-	return {x = -r.x, y = -r.y, z = -r.z}
+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.tablecopy(table) -- deep table copy
+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
 	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
@@ -159,53 +183,13 @@ 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
 end
-
--- does not overwrite values; number keys (ipairs) are appended, not overwritten
-function mesecon.mergetable(source, dest)
-	local rval = mesecon.tablecopy(dest)
-
-	for k, v in pairs(source) do
-		rval[k] = dest[k] or mesecon.tablecopy(v)
-	end
-	for i, v in ipairs(source) do
-		table.insert(rval, mesecon.tablecopy(v))
-	end
-
-	return rval
-end
-
-function mesecon.register_node(name, spec_common, spec_off, spec_on)
-	spec_common.drop = spec_common.drop or name .. "_off"
-	spec_common.__mesecon_basename = name
-	spec_on.__mesecon_state = "on"
-	spec_off.__mesecon_state = "off"
-
-	spec_on = mesecon.mergetable(spec_common, spec_on);
-	spec_off = mesecon.mergetable(spec_common, spec_off);
-
-	minetest.register_node(name .. "_on", spec_on)
-	minetest.register_node(name .. "_off", spec_off)
-end
-
--- swap onstate and offstate nodes, returns new state
-function mesecon.flipstate(pos, node)
-	local nodedef = minetest.registered_nodes[node.name]
-	local newstate
-	if (nodedef.__mesecon_state == "on") then newstate = "off" end
-	if (nodedef.__mesecon_state == "off") then newstate = "on" end
-		
-	minetest.swap_node(pos, {name = nodedef.__mesecon_basename .. "_" .. newstate,
-		param2 = node.param2})
-
-	return newstate
-end

mesecons/wires.lua

@@ -1,250 +1,280 @@
--- naming scheme: wire:(xp)(zp)(xm)(zm)(xpyp)(zpyp)(xmyp)(zmyp)_on/off
--- where x= x direction, z= z direction, y= y direction, p = +1, m = -1, e.g. xpym = {x=1, y=-1, z=0}
--- The (xp)/(zpyp)/.. statements shall be replaced by either 0 or 1
--- Where 0 means the wire has no visual connection to that direction and
--- 1 means that the wire visually connects to that other node.
+-- naming scheme: wire:(xp)(zp)(xm)(zm)_on/off
+-- The conditions in brackets define whether there is a mesecon at that place or not
+-- 1 = there is one; 0 = there is none
+-- y always means y+
 
--- #######################
--- ## Update wire looks ##
--- #######################
+box_center = {-1/16, -.5, -1/16, 1/16, -.5+1/16, 1/16}
+box_bump1 =  { -2/16, -8/16,  -2/16, 2/16, -13/32, 2/16 }
 
--- self_pos = pos of any mesecon node, from_pos = pos of conductor to getconnect for
-local wire_getconnect = function (from_pos, self_pos)
-	local node = minetest.get_node(self_pos)
-	if minetest.registered_nodes[node.name]
-	and minetest.registered_nodes[node.name].mesecons then
-		-- rules of node to possibly connect to
-		local rules = {}
-		if (minetest.registered_nodes[node.name].mesecon_wire) then
-			rules = mesecon.rules.default
-		else
-			rules = mesecon.get_any_rules(node)
-		end
+box_xp = {1/16, -.5, -1/16, 8/16, -.5+1/16, 1/16}
+box_zp = {-1/16, -.5, 1/16, 1/16, -.5+1/16, 8/16}
+box_xm = {-8/16, -.5, -1/16, -1/16, -.5+1/16, 1/16}
+box_zm = {-1/16, -.5, -8/16, 1/16, -.5+1/16, -1/16}
 
-		for _, r in ipairs(mesecon.flattenrules(rules)) do
-			if (mesecon.cmpPos(mesecon.addPosRule(self_pos, r), from_pos)) then
-				return true
-			end
-		end
-	end
-	return false
-end
+box_xpy = {.5-1/16, -.5+1/16, -1/16, .5, .4999+1/16, 1/16}
+box_zpy = {-1/16, -.5+1/16, .5-1/16, 1/16, .4999+1/16, .5}
+box_xmy = {-.5, -.5+1/16, -1/16, -.5+1/16, .4999+1/16, 1/16}
+box_zmy = {-1/16, -.5+1/16, -.5, 1/16, .4999+1/16, -.5+1/16}
 
--- Update this node
-local wire_updateconnect = function (pos)
-	local connections = {}
+-- Registering the wires
 
-	for _, r in ipairs(mesecon.rules.default) do
-		if wire_getconnect(pos, mesecon.addPosRule(pos, r)) then
-			table.insert(connections, r)
-		end
-	end
+for xp=0, 1 do
+for zp=0, 1 do
+for xm=0, 1 do
+for zm=0, 1 do
+for xpy=0, 1 do
+for zpy=0, 1 do
+for xmy=0, 1 do
+for zmy=0, 1 do
+	if (xpy == 1 and xp == 0) or (zpy == 1 and zp == 0) 
+	or (xmy == 1 and xm == 0) or (zmy == 1 and zm == 0) then break end
 
-	local nid = {}
-	for _, vec in ipairs(connections) do
-		-- flat component
-		if vec.x ==  1 then nid[0] = "1" end
-		if vec.z ==  1 then nid[1] = "1" end
-		if vec.x == -1 then nid[2] = "1" end
-		if vec.z == -1 then nid[3] = "1"  end
+	local groups
+	local nodeid = 	tostring(xp )..tostring(zp )..tostring(xm )..tostring(zm )..
+			tostring(xpy)..tostring(zpy)..tostring(xmy)..tostring(zmy)
 
-		-- slopy component
-		if vec.y == 1 then
-			if vec.x ==  1 then nid[4] = "1" end
-			if vec.z ==  1 then nid[5] = "1" end
-			if vec.x == -1 then nid[6] = "1" end
-			if vec.z == -1 then nid[7] = "1" end
-		end
-	end
-
-	local nodeid = 	  (nid[0] or "0")..(nid[1] or "0")..(nid[2] or "0")..(nid[3] or "0")
-			..(nid[4] or "0")..(nid[5] or "0")..(nid[6] or "0")..(nid[7] or "0")
-
-	local state_suffix = string.find(minetest.get_node(pos).name, "_off") and "_off" or "_on"
-	minetest.set_node(pos, {name = "mesecons:wire_"..nodeid..state_suffix})
-end
-
-local update_on_place_dig = function (pos, node)
-	-- Update placed node (get_node again as it may have been dug)
-	local nn = minetest.get_node(pos)
-	if (minetest.registered_nodes[nn.name])
-	and (minetest.registered_nodes[nn.name].mesecon_wire) then
-		wire_updateconnect(pos)
-	end
-
-	-- Update nodes around it
-	local rules = {}
-	if minetest.registered_nodes[node.name]
-	and minetest.registered_nodes[node.name].mesecon_wire then
-		rules = mesecon.rules.default
+	if nodeid == "00000000" then
+		groups = {dig_immediate = 3, mesecon_conductor_craftable=1}
+		wiredesc = "Mesecon"
 	else
-		rules = mesecon.get_any_rules(node)
-	end
-	if (not rules) then return end
-
-	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)
-		end
-	end
-end
-
-function mesecon.update_autoconnect(pos, node)
-	if (not node) then node = minetest.get_node(pos) end
-	update_on_place_dig(pos, node)
-end
-
--- ############################
--- ## Wire node registration ##
--- ############################
--- Nodeboxes:
-local box_center = {-1/16, -.5, -1/16, 1/16, -.5+1/16, 1/16}
-local box_bump1 =  { -2/16, -8/16,  -2/16, 2/16, -13/32, 2/16 }
-
-local nbox_nid =
-{
-	[0] = {1/16, -.5, -1/16, 8/16, -.5+1/16, 1/16}, -- x positive
-	[1] = {-1/16, -.5, 1/16, 1/16, -.5+1/16, 8/16}, -- z positive
-	[2] = {-8/16, -.5, -1/16, -1/16, -.5+1/16, 1/16}, -- x negative
-	[3] = {-1/16, -.5, -8/16, 1/16, -.5+1/16, -1/16}, -- z negative
-
-	[4] = {.5-1/16, -.5+1/16, -1/16, .5, .4999+1/16, 1/16}, -- x positive up
-	[5] = {-1/16, -.5+1/16, .5-1/16, 1/16, .4999+1/16, .5}, -- z positive up
-	[6] = {-.5, -.5+1/16, -1/16, -.5+1/16, .4999+1/16, 1/16}, -- x negative up
-	[7] = {-1/16, -.5+1/16, -.5, 1/16, .4999+1/16, -.5+1/16}  -- z negative up
-}
-
-local tiles_off = { "mesecons_wire_off.png" }
-local tiles_on = { "mesecons_wire_on.png" }
-
-local selectionbox =
-{
-	type = "fixed",
-	fixed = {-.5, -.5, -.5, .5, -.5+4/16, .5}
-}
-
--- go to the next nodeid (ex.: 01000011 --> 01000100)
-local nid_inc = function() end
-nid_inc = function (nid)
-	local i = 0
-	while nid[i-1] ~= 1 do
-		nid[i] = (nid[i] ~= 1) and 1 or 0
-		i = i + 1
+		groups = {dig_immediate = 3, not_in_creative_inventory = 1}
+		wiredesc = "Mesecons Wire (ID: "..nodeid..")"
 	end
 
-	-- BUT: Skip impossible nodeids:
-	if ((nid[0] == 0 and nid[4] == 1) or (nid[1] == 0 and nid[5] == 1) 
-	or (nid[2] == 0 and nid[6] == 1) or (nid[3] == 0 and nid[7] == 1)) then
-		return nid_inc(nid)
+	local nodebox = {}
+	local adjx = false
+	local adjz = false
+	if xp == 1 then table.insert(nodebox, box_xp) adjx = true end
+	if zp == 1 then table.insert(nodebox, box_zp) adjz = true end
+	if xm == 1 then table.insert(nodebox, box_xm) adjx = true end
+	if zm == 1 then table.insert(nodebox, box_zm) adjz = true end
+	if xpy == 1 then table.insert(nodebox, box_xpy) end
+	if zpy == 1 then table.insert(nodebox, box_zpy) end
+	if xmy == 1 then table.insert(nodebox, box_xmy) end
+	if zmy == 1 then table.insert(nodebox, box_zmy) end
+
+	if adjx and adjz and (xp + zp + xm + zm > 2) then
+		table.insert(nodebox, box_bump1)
+		tiles_off = {
+			"wires_bump_off.png",
+			"wires_bump_off.png",
+			"wires_vertical_off.png",
+			"wires_vertical_off.png",
+			"wires_vertical_off.png",
+			"wires_vertical_off.png"
+		}
+		tiles_on = {
+			"wires_bump_on.png",
+			"wires_bump_on.png",
+			"wires_vertical_on.png",
+			"wires_vertical_on.png",
+			"wires_vertical_on.png",
+			"wires_vertical_on.png"
+		}
+	else
+		table.insert(nodebox, box_center)
+		tiles_off = {
+			"wires_off.png",
+			"wires_off.png",
+			"wires_vertical_off.png",
+			"wires_vertical_off.png",
+			"wires_vertical_off.png",
+			"wires_vertical_off.png"
+		}
+		tiles_on = {
+			"wires_on.png",
+			"wires_on.png",
+			"wires_vertical_on.png",
+			"wires_vertical_on.png",
+			"wires_vertical_on.png",
+			"wires_vertical_on.png"
+		}
 	end
 
-	return i <= 8
-end
+	if nodeid == "00000000" then
+		nodebox = {-8/16, -.5, -1/16, 8/16, -.5+1/16, 1/16}
+	end
 
-register_wires = function()
-	local nid = {}
-	while true do
-		-- Create group specifiction and nodeid string (see note above for details)
-		local nodeid = 	  (nid[0] or "0")..(nid[1] or "0")..(nid[2] or "0")..(nid[3] or "0")
-				..(nid[4] or "0")..(nid[5] or "0")..(nid[6] or "0")..(nid[7] or "0")
-
-		-- Calculate nodebox
-		local nodebox = {type = "fixed", fixed={box_center}}
-		for i=0,7 do
-			if nid[i] == 1 then
-				table.insert(nodebox.fixed, nbox_nid[i])
-			end
-		end
-
-		-- Add bump to nodebox if curved
-		if (nid[0] == 1 and nid[1] == 1) or (nid[1] == 1 and nid[2] == 1)
-		or (nid[2] == 1 and nid[3] == 1) or (nid[3] == 1 and nid[0] == 1) then
-			table.insert(nodebox.fixed, box_bump1)
-		end
-
-		-- If nothing to connect to, still make a nodebox of a straight wire
-		if nodeid == "00000000" then
-			nodebox.fixed = {-8/16, -.5, -1/16, 8/16, -.5+1/16, 1/16}
-		end
-
-		local rules = {}
-		if (nid[0] == 1) then table.insert(rules, vector.new( 1,  0,  0)) end
-		if (nid[1] == 1) then table.insert(rules, vector.new( 0,  0,  1)) end
-		if (nid[2] == 1) then table.insert(rules, vector.new(-1,  0,  0)) end
-		if (nid[3] == 1) then table.insert(rules, vector.new( 0,  0, -1)) end
-
-		if (nid[0] == 1) then table.insert(rules, vector.new( 1, -1,  0)) end
-		if (nid[1] == 1) then table.insert(rules, vector.new( 0, -1,  1)) end
-		if (nid[2] == 1) then table.insert(rules, vector.new(-1, -1,  0)) end
-		if (nid[3] == 1) then table.insert(rules, vector.new( 0, -1, -1)) end
-
-		if (nid[4] == 1) then table.insert(rules, vector.new( 1,  1,  0)) end
-		if (nid[5] == 1) then table.insert(rules, vector.new( 0,  1,  1)) end
-		if (nid[6] == 1) then table.insert(rules, vector.new(-1,  1,  0)) end
-		if (nid[7] == 1) then table.insert(rules, vector.new( 0,  1, -1)) end
-
-		local meseconspec_off = { conductor = {
-			rules = rules,
+	minetest.register_node("mesecons:wire_"..nodeid.."_off", {
+		description = wiredesc,
+		drawtype = "nodebox",
+		tiles = tiles_off,
+--		inventory_image = "wires_inv.png",
+--		wield_image = "wires_inv.png",
+		inventory_image = "jeija_mesecon_off.png",
+		wield_image = "jeija_mesecon_off.png",
+		paramtype = "light",
+		paramtype2 = "facedir",
+		sunlight_propagates = true,
+		selection_box = {
+              		type = "fixed",
+			fixed = {-.5, -.5, -.5, .5, -.5+4/16, .5}
+		},
+		node_box = {
+			type = "fixed",
+			fixed = nodebox
+		},
+		groups = groups,
+		walkable = false,
+		stack_max = 99,
+		drop = "mesecons:wire_00000000_off",
+		mesecons = {conductor={
 			state = mesecon.state.off,
 			onstate = "mesecons:wire_"..nodeid.."_on"
 		}}
+	})
 
-		local meseconspec_on = { conductor = {
-			rules = rules,
+	minetest.register_node("mesecons:wire_"..nodeid.."_on", {
+		description = "Wire ID:"..nodeid,
+		drawtype = "nodebox",
+		tiles = tiles_on,
+--		inventory_image = "wires_inv.png",
+--		wield_image = "wires_inv.png",
+		inventory_image = "jeija_mesecon_off.png",
+		wield_image = "jeija_mesecon_off.png",
+		paramtype = "light",
+		paramtype2 = "facedir",
+		sunlight_propagates = true,
+		selection_box = {
+              		type = "fixed",
+			fixed = {-.5, -.5, -.5, .5, -.5+4/16, .5}
+		},
+		node_box = {
+			type = "fixed",
+			fixed = nodebox
+		},
+		groups = {dig_immediate = 3, mesecon = 2, not_in_creative_inventory = 1},
+		walkable = false,
+		stack_max = 99,
+		drop = "mesecons:wire_00000000_off",
+		mesecons = {conductor={
 			state = mesecon.state.on,
 			offstate = "mesecons:wire_"..nodeid.."_off"
 		}}
+	})
+end
+end
+end
+end
+end
+end
+end
+end
 
-		local groups_on = {dig_immediate = 3, mesecon_conductor_craftable = 1,
-			not_in_creative_inventory = 1}
-		local groups_off = {dig_immediate = 3, mesecon_conductor_craftable = 1}
-		if nodeid ~= "00000000" then
-			groups_off["not_in_creative_inventory"] = 1
-		end
+-- Updating the wires:
+-- Place the right connection wire
 
-		mesecon.register_node("mesecons:wire_"..nodeid, {
-			description = "Mesecon",
-			drawtype = "nodebox",
-			inventory_image = "mesecons_wire_inv.png",
-			wield_image = "mesecons_wire_inv.png",
-			paramtype = "light",
-			paramtype2 = "facedir",
-			sunlight_propagates = true,
-			selection_box = selectionbox,
-			node_box = nodebox,
-			walkable = false,
-			drop = "mesecons:wire_00000000_off",
-			mesecon_wire = true
-		}, {tiles = tiles_off, mesecons = meseconspec_off, groups = groups_off},
-		{tiles = tiles_on, mesecons = meseconspec_on, groups = groups_on})
-
-		if (nid_inc(nid) == false) then return end
+local update_on_place_dig = function (pos, node)
+	if minetest.registered_nodes[node.name]
+	and minetest.registered_nodes[node.name].mesecons then
+		mesecon:update_autoconnect(pos)
 	end
 end
-register_wires()
 
--- ##############
--- ## Crafting ##
--- ##############
-minetest.register_craft({
-	type = "cooking",
-	output = "mesecons:wire_00000000_off 2",
-	recipe = "default:mese_crystal_fragment",
-	cooktime = 3,
-})
+minetest.register_on_placenode(update_on_place_dig)
+minetest.register_on_dignode(update_on_place_dig)
+
+function mesecon:update_autoconnect(pos, secondcall, replace_old)
+	local xppos = {x=pos.x+1, y=pos.y, z=pos.z}
+	local zppos = {x=pos.x, y=pos.y, z=pos.z+1}
+	local xmpos = {x=pos.x-1, y=pos.y, z=pos.z}
+	local zmpos = {x=pos.x, y=pos.y, z=pos.z-1}
+
+	local xpympos = {x=pos.x+1, y=pos.y-1, z=pos.z}
+	local zpympos = {x=pos.x, y=pos.y-1, z=pos.z+1}
+	local xmympos = {x=pos.x-1, y=pos.y-1, z=pos.z}
+	local zmympos = {x=pos.x, y=pos.y-1, z=pos.z-1}
+
+	local xpypos = {x=pos.x+1, y=pos.y+1, z=pos.z}
+	local zpypos = {x=pos.x, y=pos.y+1, z=pos.z+1}
+	local xmypos = {x=pos.x-1, y=pos.y+1, z=pos.z}
+	local zmypos = {x=pos.x, y=pos.y+1, z=pos.z-1}
+
+	if secondcall == nil then
+		mesecon:update_autoconnect(xppos, true)
+		mesecon:update_autoconnect(zppos, true)
+		mesecon:update_autoconnect(xmpos, true)
+		mesecon:update_autoconnect(zmpos, true)
+
+		mesecon:update_autoconnect(xpypos, true)
+		mesecon:update_autoconnect(zpypos, true)
+		mesecon:update_autoconnect(xmypos, true)
+		mesecon:update_autoconnect(zmypos, true)
+
+		mesecon:update_autoconnect(xpympos, true)
+		mesecon:update_autoconnect(zpympos, true)
+		mesecon:update_autoconnect(xmympos, true)
+		mesecon:update_autoconnect(zmympos, true)
+	end
+
+	nodename = minetest.get_node(pos).name
+	if string.find(nodename, "mesecons:wire_") == nil and not replace_old then return nil end
+
+	if mesecon:rules_link_anydir(pos, xppos) then xp = 1 else xp = 0 end
+	if mesecon:rules_link_anydir(pos, xmpos) then xm = 1 else xm = 0 end
+	if mesecon:rules_link_anydir(pos, zppos) then zp = 1 else zp = 0 end
+	if mesecon:rules_link_anydir(pos, zmpos) then zm = 1 else zm = 0 end
+
+	if mesecon:rules_link_anydir(pos, xpympos) then xp = 1 end
+	if mesecon:rules_link_anydir(pos, xmympos) then xm = 1 end
+	if mesecon:rules_link_anydir(pos, zpympos) then zp = 1 end
+	if mesecon:rules_link_anydir(pos, zmympos) then zm = 1 end
+
+	if mesecon:rules_link_anydir(pos, xpypos) then xpy = 1 else xpy = 0 end
+	if mesecon:rules_link_anydir(pos, zpypos) then zpy = 1 else zpy = 0 end
+	if mesecon:rules_link_anydir(pos, xmypos) then xmy = 1 else xmy = 0 end
+	if mesecon:rules_link_anydir(pos, zmypos) then zmy = 1 else zmy = 0 end
+
+	if xpy == 1 then xp = 1 end
+	if zpy == 1 then zp = 1 end
+	if xmy == 1 then xm = 1 end
+	if zmy == 1 then zm = 1 end
+
+	local nodeid = 	tostring(xp )..tostring(zp )..tostring(xm )..tostring(zm )..
+			tostring(xpy)..tostring(zpy)..tostring(xmy)..tostring(zmy)
+
+	
+	if string.find(nodename, "_off") ~= nil then
+		minetest.set_node(pos, {name = "mesecons:wire_"..nodeid.."_off"})
+	else
+		minetest.set_node(pos, {name = "mesecons:wire_"..nodeid.."_on" })
+	end
+end
+
+if not minetest.registered_nodes["default:stone_with_mese"] then --before MESE update, use old recipes
+	minetest.register_craft({
+		output = "mesecons:wire_00000000_off 18",
+		recipe = {
+			{"default:mese"},
+		}
+	})
+else
+
+	minetest.register_craft({
+		type = "cooking",
+		output = "mesecons:wire_00000000_off 2",
+		recipe = "default:mese_crystal_fragment",
+		cooktime = 3,
+	})
+
+	minetest.register_craft({
+		type = "cooking",
+		output = "mesecons:wire_00000000_off 18",
+		recipe = "default:mese_crystal",
+		cooktime = 15,
+	})
+
+	minetest.register_craft({
+		type = "cooking",
+		output = "mesecons:wire_00000000_off 162",
+		recipe = "default:mese",
+		cooktime = 30,
+	})
+
+end
 
 minetest.register_craft({
 	type = "cooking",
-	output = "mesecons:wire_00000000_off 18",
+	output = "mesecons:wire_00000000_off 16",
 	recipe = "default:mese_crystal",
-	cooktime = 15,
-})
-
-minetest.register_craft({
-	type = "cooking",
-	output = "mesecons:wire_00000000_off 162",
-	recipe = "default:mese",
-	cooktime = 30,
 })

mesecons_blinkyplant/init.lua

@@ -1,51 +1,102 @@
 -- The BLINKY_PLANT
-
-local toggle_timer = function (pos)
-	local timer = minetest.get_node_timer(pos)
-	if timer:is_started() then
-		timer:stop()
-	else
-		timer:start(mesecon.setting("blinky_plant_interval", 3))
-	end
-end
-
-local on_timer = function (pos)
-	local node = minetest.get_node(pos)
-	if(mesecon.flipstate(pos, node) == "on") then
-		mesecon.receptor_on(pos)
-	else
-		mesecon.receptor_off(pos)
-	end
-	toggle_timer(pos)
-end
-
-mesecon.register_node("mesecons_blinkyplant:blinky_plant", {
-	description="Blinky Plant",
+minetest.register_node("mesecons_blinkyplant:blinky_plant", {
 	drawtype = "plantlike",
+	visual_scale = 1,
+	tiles = {"jeija_blinky_plant_off.png"},
 	inventory_image = "jeija_blinky_plant_off.png",
-	paramtype = "light",
 	walkable = false,
+	groups = {dig_immediate=3, not_in_creative_inventory=1},
+	drop="mesecons_blinkyplant:blinky_plant_off 1",
+    description="Deactivated Blinky Plant",
 	sounds = default.node_sound_leaves_defaults(),
 	selection_box = {
 		type = "fixed",
 		fixed = {-0.3, -0.5, -0.3, 0.3, -0.5+0.7, 0.3},
 	},
-	on_timer = on_timer,
-	on_rightclick = toggle_timer,
-	on_construct = toggle_timer
-},{
+	mesecons = {receptor = {
+		state = mesecon.state.off
+	}},
+	on_rightclick = function(pos, node, clicker)
+        minetest.set_node(pos, {name="mesecons_blinkyplant:blinky_plant_off"})
+    end	
+})
+
+minetest.register_node("mesecons_blinkyplant:blinky_plant_off", {
+	drawtype = "plantlike",
+	visual_scale = 1,
 	tiles = {"jeija_blinky_plant_off.png"},
-	groups = {dig_immediate=3},
-	mesecons = {receptor = { state = mesecon.state.off }}
-},{
+	inventory_image = "jeija_blinky_plant_off.png",
+	paramtype = "light",
+	walkable = false,
+	groups = {dig_immediate=3, mesecon=2},
+    description="Blinky Plant",
+	sounds = default.node_sound_leaves_defaults(),
+	selection_box = {
+		type = "fixed",
+		fixed = {-0.3, -0.5, -0.3, 0.3, -0.5+0.7, 0.3},
+	},
+	mesecons = {receptor = {
+		state = mesecon.state.off
+	}},
+	on_rightclick = function(pos, node, clicker)
+        minetest.set_node(pos, {name="mesecons_blinkyplant:blinky_plant"})
+    end
+})
+
+minetest.register_node("mesecons_blinkyplant:blinky_plant_on", {
+	drawtype = "plantlike",
+	visual_scale = 1,
 	tiles = {"jeija_blinky_plant_on.png"},
-	groups = {dig_immediate=3, not_in_creative_inventory=1},
-	mesecons = {receptor = { state = mesecon.state.on }}
+	inventory_image = "jeija_blinky_plant_off.png",
+	paramtype = "light",
+	walkable = false,
+	groups = {dig_immediate=3, not_in_creative_inventory=1, mesecon=2},
+	drop="mesecons_blinkyplant:blinky_plant_off 1",
+	light_source = LIGHT_MAX-7,
+	description = "Blinky Plant",
+	sounds = default.node_sound_leaves_defaults(),
+	selection_box = {
+		type = "fixed",
+		fixed = {-0.3, -0.5, -0.3, 0.3, -0.5+0.7, 0.3},
+	},
+	mesecons = {receptor = {
+		state = mesecon.state.on
+	}},
+	on_rightclick = function(pos, node, clicker)
+		minetest.set_node(pos, {name = "mesecons_blinkyplant:blinky_plant"})
+		mesecon:receptor_off(pos)
+	end
 })
 
 minetest.register_craft({
 	output = "mesecons_blinkyplant:blinky_plant_off 1",
-	recipe = {	{"","group:mesecon_conductor_craftable",""},
-			{"","group:mesecon_conductor_craftable",""},
-			{"group:sapling","group:sapling","group:sapling"}}
+	recipe = {
+	{"","group:mesecon_conductor_craftable",""},
+	{"","group:mesecon_conductor_craftable",""},
+	{"default:sapling","default:sapling","default:sapling"},
+	}
+})
+
+minetest.register_abm(
+	{nodenames = {"mesecons_blinkyplant:blinky_plant_off"},
+	interval = BLINKY_PLANT_INTERVAL,
+	chance = 1,
+	action = function(pos, node, active_object_count, active_object_count_wider)
+		--minetest.remove_node(pos)
+		minetest.add_node(pos, {name="mesecons_blinkyplant:blinky_plant_on"})
+		nodeupdate(pos)	
+		mesecon:receptor_on(pos)
+	end,
+})
+
+minetest.register_abm({
+	nodenames = {"mesecons_blinkyplant:blinky_plant_on"},
+	interval = BLINKY_PLANT_INTERVAL,
+	chance = 1,
+	action = function(pos, node, active_object_count, active_object_count_wider)
+		--minetest.remove_node(pos)
+		minetest.add_node(pos, {name="mesecons_blinkyplant:blinky_plant_off"})
+		nodeupdate(pos)	
+		mesecon:receptor_off(pos)
+	end,
 })

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,

mesecons_commandblock/init.lua

@@ -79,7 +79,7 @@ local function after_place(pos, placer)
 end
 
 local function receive_fields(pos, formname, fields, sender)
-	if not fields.submit then
+	if fields.quit then
 		return
 	end
 	local meta = minetest.get_meta(pos)

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

mesecons_detector/init.lua

@@ -1,5 +1,3 @@
-local GET_COMMAND = "GET"
-
 -- Object detector
 -- Detects players in a certain radius
 -- The radius can be specified in mesecons/settings.lua
@@ -23,7 +21,7 @@ end
 
 -- returns true if player was found, false if not
 local object_detector_scan = function (pos)
-	local objs = minetest.get_objects_inside_radius(pos, mesecon.setting("detector_radius", 6))
+	local objs = minetest.get_objects_inside_radius(pos, OBJECT_DETECTOR_RADIUS)
 	for k, obj in pairs(objs) do
 		local isname = obj:get_player_name() -- "" is returned if it is not a player; "" ~= nil!
 		local scanname = minetest.get_meta(pos):get_string("scanname")
@@ -35,7 +33,7 @@ local object_detector_scan = function (pos)
 end
 
 -- set player name when receiving a digiline signal on a specific channel
-local object_detector_digiline = {
+object_detector_digiline = {
 	effector = {
 		action = function (pos, node, channel, msg)
 			local meta = minetest.get_meta(pos)
@@ -55,8 +53,7 @@ minetest.register_node("mesecons_detector:object_detector_off", {
 	groups = {cracky=3},
 	description="Player Detector",
 	mesecons = {receptor = {
-		state = mesecon.state.off,
-		rules = mesecon.rules.pplate
+		state = mesecon.state.off
 	}},
 	on_construct = object_detector_make_formspec,
 	on_receive_fields = object_detector_on_receive_fields,
@@ -71,8 +68,7 @@ minetest.register_node("mesecons_detector:object_detector_on", {
 	groups = {cracky=3,not_in_creative_inventory=1},
 	drop = 'mesecons_detector:object_detector_off',
 	mesecons = {receptor = {
-		state = mesecon.state.on,
-		rules = mesecon.rules.pplate
+		state = mesecon.state.on
 	}},
 	on_construct = object_detector_make_formspec,
 	on_receive_fields = object_detector_on_receive_fields,
@@ -96,7 +92,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)
 		end
 	end,
 })
@@ -108,161 +104,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)
-		end
-	end,
-})
-
--- Node detector
--- Detects the node in front of it
-
-local node_detector_make_formspec = function (pos)
-	local meta = minetest.get_meta(pos)
-	meta:set_string("formspec", "size[9,2.5]" ..
-		"field[0.3,  0;9,2;scanname;Name of node to scan for (empty for any):;${scanname}]"..
-		"field[0.3,1.5;4,2;digiline_channel;Digiline Channel (optional):;${digiline_channel}]"..
-		"button_exit[7,0.75;2,3;;Save]")
-end
-
-local node_detector_on_receive_fields = function(pos, formname, fields)
-	if not fields.scanname or not fields.digiline_channel then return end;
-
-	local meta = minetest.get_meta(pos)
-	meta:set_string("scanname", fields.scanname)
-	meta:set_string("digiline_channel", fields.digiline_channel)
-	node_detector_make_formspec(pos)
-end
-
--- returns true if player was found, false if not
-local node_detector_scan = function (pos)
-	local node = minetest.get_node(pos)
-	local frontpos = vector.subtract(pos, minetest.facedir_to_dir(node.param2))
-	local frontnode = minetest.get_node(frontpos)
-	local meta = minetest.get_meta(pos)
-	return (frontnode.name == meta:get_string("scanname")) or
-		(frontnode.name ~= "air" and frontnode.name ~= "ignore" and meta:get_string("scanname") == "")
-end
-
--- set player name when receiving a digiline signal on a specific channel
-local node_detector_digiline = {
-	effector = {
-		action = function (pos, node, channel, msg)
-			local meta = minetest.get_meta(pos)
-			local active_channel = meta:get_string("digiline_channel")
-			if channel == active_channel then
-				if msg == GET_COMMAND then
-					local frontpos = vector.subtract(pos, minetest.facedir_to_dir(node.param2))
-					local name = minetest.get_node(frontpos).name
-					digiline:receptor_send(pos, digiline.rules.default, channel, name)
-				else
-					meta:set_string("scanname", msg)
-					node_detector_make_formspec(pos)
-				end
-			end
-		end,
-	},
-	receptor = {}
-}
-
-minetest.register_node("mesecons_detector:node_detector_off", {
-	tiles = {"default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "jeija_node_detector_off.png"},
-	paramtype = "light",
-	paramtype2 = "facedir",
-	walkable = true,
-	groups = {cracky=3},
-	description="Node Detector",
-	mesecons = {receptor = {
-		state = mesecon.state.off
-	}},
-	on_construct = node_detector_make_formspec,
-	on_receive_fields = node_detector_on_receive_fields,
-	after_place_node = function (pos, placer)
-		local placer_pos = placer:getpos()
-		
-		--correct for the player's height
-		if placer:is_player() then placer_pos.y = placer_pos.y + 1.5 end
-		
-		--correct for 6d facedir
-		if placer_pos then
-			local dir = {
-				x = pos.x - placer_pos.x,
-				y = pos.y - placer_pos.y,
-				z = pos.z - placer_pos.z
-			}
-			local node = minetest.get_node(pos)
-			node.param2 = minetest.dir_to_facedir(dir, true)
-			minetest.set_node(pos, node)
-			minetest.log("action", "real (6d) facedir: " .. node.param2)
-		end
-	end,
-	sounds = default.node_sound_stone_defaults(),
-	digiline = node_detector_digiline
-})
-
-minetest.register_node("mesecons_detector:node_detector_on", {
-	tiles = {"default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "jeija_node_detector_on.png"},
-	paramtype = "light",
-	paramtype2 = "facedir",
-	walkable = true,
-	groups = {cracky=3,not_in_creative_inventory=1},
-	drop = 'mesecons_detector:node_detector_off',
-	mesecons = {receptor = {
-		state = mesecon.state.on
-	}},
-	on_construct = node_detector_make_formspec,
-	on_receive_fields = node_detector_on_receive_fields,
-	after_place_node = function (pos, placer)
-		local placer_pos = placer:getpos()
-		
-		--correct for the player's height
-		if placer:is_player() then placer_pos.y = placer_pos.y + 1.5 end
-		
-		--correct for 6d facedir
-		if placer_pos then
-			local dir = {
-				x = pos.x - placer_pos.x,
-				y = pos.y - placer_pos.y,
-				z = pos.z - placer_pos.z
-			}
-			local node = minetest.get_node(pos)
-			node.param2 = minetest.dir_to_facedir(dir, true)
-			minetest.set_node(pos, node)
-			minetest.log("action", "real (6d) facedir: " .. node.param2)
-		end
-	end,
-	sounds = default.node_sound_stone_defaults(),
-	digiline = node_detector_digiline
-})
-
-minetest.register_craft({
-	output = 'mesecons_detector:node_detector_off',
-	recipe = {
-		{"default:steel_ingot", "group:mesecon_conductor_craftable", "default:steel_ingot"},
-		{"default:steel_ingot", "mesecons_luacontroller:luacontroller0000", "default:steel_ingot"},
-		{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
-	}
-})
-
-minetest.register_abm(
-	{nodenames = {"mesecons_detector:node_detector_off"},
-	interval = 1.0,
-	chance = 1,
-	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)
-		end
-	end,
-})
-
-minetest.register_abm(
-	{nodenames = {"mesecons_detector:node_detector_on"},
-	interval = 1.0,
-	chance = 1,
-	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,
 })

mesecons_doors/depends.txt

@@ -1,2 +1,2 @@
-mesecons
 doors
+mesecons

mesecons_doors/init.lua

@@ -1,80 +1,130 @@
--- Modified, from minetest_game/mods/doors/init.lua
-local function on_rightclick(pos, dir, check_name, replace, replace_dir, params)
-	pos.y = pos.y + dir
-	if not minetest.get_node(pos).name == check_name then
-		return
-	end
-	local p2 = minetest.get_node(pos).param2
-	p2 = params[p2 + 1]
-
-	minetest.swap_node(pos, {name = replace_dir, param2 = p2})
-
-	pos.y = pos.y - dir
-	minetest.swap_node(pos, {name = replace, param2 = p2})
-
-	if (minetest.get_meta(pos):get_int("right") ~= 0) == (params[1] ~= 3) then
-		minetest.sound_play("door_close", {pos = pos, gain = 0.3, max_hear_distance = 10})
-	else
-		minetest.sound_play("door_open", {pos = pos, gain = 0.3, max_hear_distance = 10})
-	end
-end
-
-local function meseconify_door(name)
-	local function toggle_state1 (pos, node)
-		on_rightclick(pos, 1, name.."_t_1", name.."_b_2", name.."_t_2", {1,2,3,0})
-	end
-
-	local function toggle_state2 (pos, node)
-		on_rightclick(pos, 1, name.."_t_2", name.."_b_1", name.."_t_1", {3,0,1,2})
-	end
-
-	minetest.override_item(name.."_b_1", {
-		mesecons = {effector = {
-			action_on = toggle_state1,
-			action_off = toggle_state1,
-			rules = mesecon.rules.pplate
-		}},
+local other_state_node = {}
+for _, material in ipairs({
+	{ id = "wood", desc = "Wooden", color = "brown" },
+	{ id = "steel", desc = "Steel", color = "grey" },
+}) do
+	doors:register_door("mesecons_doors:op_door_"..material.id, {
+		description = "Mesecon-operated "..material.desc.." Door",
+		inventory_image = minetest.registered_items["doors:door_"..material.id].inventory_image,
+		groups = minetest.registered_nodes["doors:door_"..material.id.."_b_1"].groups,
+		tiles_bottom = {"door_"..material.id.."_b.png", "door_"..material.color..".png"},
+		tiles_top = {"door_"..material.id.."_a.png", "door_"..material.color..".png"},
 	})
-
-	minetest.override_item(name.."_b_2", {
-		mesecons = {effector = {
-			action_on = toggle_state2,
-			action_off = toggle_state2,
-			rules = mesecon.rules.pplate
-		}},
+	local groups_plus_mesecon = { mesecon = 2 }
+	for k, v in pairs(minetest.registered_nodes["doors:door_"..material.id.."_b_1"].groups) do
+		groups_plus_mesecon[k] = v
+	end
+	doors:register_door("mesecons_doors:sig_door_"..material.id, {
+		description = "Mesecon-signalling "..material.desc.." Door",
+		inventory_image = minetest.registered_items["doors:door_"..material.id].inventory_image,
+		groups = groups_plus_mesecon,
+		tiles_bottom = {"door_"..material.id.."_b.png", "door_"..material.color..".png"},
+		tiles_top = {"door_"..material.id.."_a.png", "door_"..material.color..".png"},
+	})
+	for _, thishalf in ipairs({ "t", "b" }) do
+		local otherhalf = thishalf == "t" and "b" or "t"
+		local otherdir = thishalf == "t" and -1 or 1
+		for orientation = 1, 2 do
+			local thissuffix = material.id.."_"..thishalf.."_"..orientation
+			local othersuffix = material.id.."_"..otherhalf.."_"..orientation
+			local thisopname = "mesecons_doors:op_door_"..thissuffix
+			local otheropname = "mesecons_doors:op_door_"..othersuffix
+			local oponr = minetest.registered_nodes[thisopname].on_rightclick
+			local function handle_mesecon_signal (thispos, thisnode, signal)
+				local thismeta = minetest.get_meta(thispos)
+				if signal == thismeta:get_int("sigstate") then return end
+				thismeta:set_int("sigstate", signal)
+				local otherpos = { x = thispos.x, y = thispos.y + otherdir, z = thispos.z }
+				if minetest.get_node(otherpos).name ~= otheropname then return end
+				local othermeta = minetest.get_meta(otherpos)
+				local newdoorstate = math.max(thismeta:get_int("sigstate"), othermeta:get_int("sigstate"))
+				if newdoorstate == thismeta:get_int("doorstate") then return end
+				oponr(thispos, thisnode, nil)
+				thismeta:set_int("doorstate", newdoorstate)
+				othermeta:set_int("doorstate", newdoorstate)
+			end
+			minetest.override_item(thisopname, {
+				on_construct = function (pos)
+					if mesecon:is_powered(pos) then
+						local node = minetest.get_node(pos)
+						mesecon:changesignal(pos, node, mesecon:effector_get_rules(node), "on", 1)
+						mesecon:activate(pos, node, nil, 1)
+					end
+				end,
+				on_rightclick = function (pos, node, clicker) end,
+				mesecons = {
+					effector = {
+						action_on = function (pos, node)
+							handle_mesecon_signal(pos, node, 1)
+						end,
+						action_off = function (pos, node)
+							handle_mesecon_signal(pos, node, 0)
+						end,
+					},
+				},
+			})
+			local thissigname = "mesecons_doors:sig_door_"..thissuffix
+			local othersigname = "mesecons_doors:sig_door_"..othersuffix
+			local sigonr = minetest.registered_nodes[thissigname].on_rightclick
+			minetest.override_item(thissigname, {
+				on_rightclick = function (thispos, thisnode, clicker)
+					local otherpos = { x = thispos.x, y = thispos.y + otherdir, z = thispos.z }
+					print("open: otherpos.name="..minetest.get_node(otherpos).name..", othersigname="..othersigname)
+					if minetest.get_node(otherpos).name ~= othersigname then return end
+					sigonr(thispos, thisnode, clicker)
+					for _, pos in ipairs({ thispos, otherpos }) do
+						local node = minetest.get_node(pos)
+						node.name = other_state_node[node.name]
+						minetest.swap_node(pos, node)
+						mesecon:receptor_on(pos)
+					end
+				end,
+				mesecons = { receptor = { state = mesecon.state.off } },
+			})
+			other_state_node[thissigname] = thissigname.."_on"
+			local ondef = {}
+			for k, v in pairs(minetest.registered_nodes[thissigname]) do
+				ondef[k] = v
+			end
+			ondef.on_rightclick = function (thispos, thisnode, clicker)
+				local otherpos = { x = thispos.x, y = thispos.y + otherdir, z = thispos.z }
+				print("close: otherpos.name="..minetest.get_node(otherpos).name..", othersigname="..othersigname)
+				if minetest.get_node(otherpos).name ~= othersigname.."_on" then return end
+				for _, pos in ipairs({ thispos, otherpos }) do
+					local node = minetest.get_node(pos)
+					node.name = other_state_node[node.name]
+					minetest.swap_node(pos, node)
+					mesecon:receptor_off(pos)
+				end
+				sigonr(thispos, thisnode, clicker)
+			end
+			ondef.mesecons = { receptor = { state = mesecon.state.on } }
+			ondef.after_destruct = function (thispos, thisnode)
+				local otherpos = { x = thispos.x, y = thispos.y + otherdir, z = thispos.z }
+				if minetest.get_node(otherpos).name == othersigname.."_on" then
+					minetest.remove_node(otherpos)
+					mesecon:receptor_off(otherpos)
+				end
+			end
+			other_state_node[thissigname.."_on"] = thissigname
+			ondef.mesecon_other_state_node = thissigname
+			minetest.register_node(thissigname.."_on", ondef)
+		end
+	end
+	minetest.register_craft({
+		output = "mesecons_doors:op_door_"..material.id,
+		recipe = {
+			{ "group:mesecon_conductor_craftable", "", "" },
+			{ "", "doors:door_"..material.id, "group:mesecon_conductor_craftable" },
+			{ "group:mesecon_conductor_craftable", "", "" },
+		},
+	})
+	minetest.register_craft({
+		output = "mesecons_doors:sig_door_"..material.id,
+		recipe = {
+			{ "", "", "group:mesecon_conductor_craftable" },
+			{ "group:mesecon_conductor_craftable", "doors:door_"..material.id, "" },
+			{ "", "", "group:mesecon_conductor_craftable" },
+		},
 	})
 end
-
-meseconify_door("doors:door_wood")
-meseconify_door("doors:door_steel")
-meseconify_door("doors:door_glass")
-meseconify_door("doors:door_obsidian_glass")
-
--- Trapdoor
-local function trapdoor_switch(pos, node)
-	local state = minetest.get_meta(pos):get_int("state")
-
-	if state == 1 then
-		minetest.sound_play("doors_door_close", {pos = pos, gain = 0.3, max_hear_distance = 10})
-		minetest.set_node(pos, {name="doors:trapdoor", param2 = node.param2})
-	else
-		minetest.sound_play("doors_door_open", {pos = pos, gain = 0.3, max_hear_distance = 10})
-		minetest.set_node(pos, {name="doors:trapdoor_open", param2 = node.param2})
-	end
-
-	minetest.get_meta(pos):set_int("state", state == 1 and 0 or 1)
-end
-
-minetest.override_item("doors:trapdoor", {
-	mesecons = {effector = {
-		action_on = trapdoor_switch,
-		action_off = trapdoor_switch
-	}},
-})
-
-minetest.override_item("doors:trapdoor_open", {
-	mesecons = {effector = {
-		action_on = trapdoor_switch,
-		action_off = trapdoor_switch
-	}},
-})

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

mesecons_extrawires/mesewire.lua

@@ -8,7 +8,12 @@ local mesewire_rules =
 	{x = 0, y = 0, z =-1},
 }
 
-minetest.override_item("default:mese", {
+minetest.register_node(":default:mese", {
+	description = "Mese Block",
+	tiles = {minetest.registered_nodes["default:mese"].tiles[1]},
+	is_ground_content = true,
+	groups = {cracky=1},
+	sounds = default.node_sound_stone_defaults(),
 	mesecons = {conductor = {
 		state = mesecon.state.off,
 		onstate = "mesecons_extrawires:mese_powered",

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

mesecons_extrawires/vertical.lua

@@ -18,7 +18,7 @@ local bottom_box = {
 
 local vertical_rules = {
 	{x=0, y=1, z=0},
-	{x=0, y=-1, z=0}
+	{x=0, y=-1, z=0},
 }
 
 local top_rules = {
@@ -26,7 +26,7 @@ local top_rules = {
 	{x=-1,y=0, z=0},
 	{x=0,y=0, z=1},
 	{x=0,y=0, z=-1},
-	{x=0,y=-1, z=0}
+	{x=0,y=-1, z=0},
 }
 
 local bottom_rules = {
@@ -35,79 +35,85 @@ local bottom_rules = {
 	{x=0, y=0, z=1},
 	{x=0, y=0, z=-1},
 	{x=0, y=1, z=0},
-	{x=0, y=2, z=0} -- receive power from pressure plate / detector / ... 2 nodes above
 }
 
 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]))
+	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 namestate = minetest.registered_nodes[node.name].vertical_conductor_state
 
-		local above = minetest.registered_nodes[node_above.name]
-			and minetest.registered_nodes[node_above.name].is_vertical_conductor
-		local below = minetest.registered_nodes[node_below.name]
-			and minetest.registered_nodes[node_below.name].is_vertical_conductor
+		local above = minetest.registered_nodes[node_above.name] and minetest.registered_nodes[node_above.name].is_vertical_conductor
+		local below = minetest.registered_nodes[node_below.name] and minetest.registered_nodes[node_below.name].is_vertical_conductor
 
-		local basename = "mesecons_extrawires:vertical_"
 		if above and below then -- above and below: vertical mesecon
-			minetest.add_node(pos, {name = basename .. namestate})
+			minetest.add_node(pos, {name = "mesecons_extrawires:vertical_" .. namestate})
 		elseif above and not below then -- above only: bottom
-			minetest.add_node(pos, {name = basename .. "bottom_" .. namestate})
+			minetest.add_node(pos, {name = "mesecons_extrawires:vertical_bottom_" .. namestate})
 		elseif not above and below then -- below only: top
-			minetest.add_node(pos, {name = basename .. "top_" .. namestate})
-		else -- no vertical wire above, no vertical wire below: use bottom
-			minetest.add_node(pos, {name = basename .. "bottom_" .. namestate})
+			minetest.add_node(pos, {name = "mesecons_extrawires:vertical_top_" .. namestate})
+		else -- no vertical wire above, no vertical wire below: use default wire
+			minetest.add_node(pos, {name = "mesecons_extrawires:vertical_" .. namestate})
 		end
-		mesecon.update_autoconnect(pos)
 	end
 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
-mesecon.register_node("mesecons_extrawires:vertical", {
+minetest.register_node("mesecons_extrawires:vertical_on", {
 	description = "Vertical mesecon",
 	drawtype = "nodebox",
+	tiles = {"wires_vertical_on.png"},
 	walkable = false,
 	paramtype = "light",
 	sunlight_propagates = true,
+	groups = {dig_immediate=3, not_in_creative_inventory=1},
 	selection_box = vertical_box,
 	node_box = vertical_box,
 	is_vertical_conductor = true,
-	drop = "mesecons_extrawires:vertical_off",
-	after_place_node = vertical_update,
-	after_dig_node = vertical_update
-},{
-	tiles = {"mesecons_wire_off.png"},
-	groups = {dig_immediate=3},
-	vertical_conductor_state = "off",
-	mesecons = {conductor = {
-		state = mesecon.state.off,
-		onstate = "mesecons_extrawires:vertical_on",
-		rules = vertical_rules,
-	}}
-},{
-	tiles = {"mesecons_wire_on.png"},
-	groups = {dig_immediate=3, not_in_creative_inventory=1},
 	vertical_conductor_state = "on",
 	mesecons = {conductor = {
 		state = mesecon.state.on,
 		offstate = "mesecons_extrawires:vertical_off",
 		rules = vertical_rules,
-	}}
+	}},
+	drop = "mesecons_extrawires:vertical_off",
+	after_place_node = vertical_update,
+	after_dig_node = vertical_update,
+})
+
+minetest.register_node("mesecons_extrawires:vertical_off", {
+	description = "Vertical mesecon",
+	drawtype = "nodebox",
+	tiles = {"wires_vertical_off.png"},
+	walkable = false,
+	paramtype = "light",
+	sunlight_propagates = true,
+	groups = {dig_immediate=3},
+	selection_box = vertical_box,
+	node_box = vertical_box,
+	is_vertical_conductor = true,
+	vertical_conductor_state = "off",
+	mesecons = {conductor = {
+		state = mesecon.state.off,
+		onstate = "mesecons_extrawires:vertical_on",
+		rules = vertical_rules,
+	}},
+	after_place_node = vertical_update,
+	after_dig_node = vertical_update,
 })
 
 -- Vertical wire top
-mesecon.register_node("mesecons_extrawires:vertical_top", {
+minetest.register_node("mesecons_extrawires:vertical_top_on", {
 	description = "Vertical mesecon",
 	drawtype = "nodebox",
+	tiles = {"wires_full_on.png","wires_full_on.png","wires_vertical_on.png"},
 	walkable = false,
 	paramtype = "light",
 	sunlight_propagates = true,
@@ -115,31 +121,65 @@ mesecon.register_node("mesecons_extrawires:vertical_top", {
 	selection_box = top_box,
 	node_box = top_box,
 	is_vertical_conductor = true,
-	drop = "mesecons_extrawires:vertical_off",
-	after_place_node = vertical_update,
-	after_dig_node = vertical_update
-},{
-	tiles = {"mesecons_wire_off.png"},
-	vertical_conductor_state = "off",
-	mesecons = {conductor = {
-		state = mesecon.state.off,
-		onstate = "mesecons_extrawires:vertical_top_on",
-		rules = top_rules,
-	}}
-},{
-	tiles = {"mesecons_wire_on.png"},
 	vertical_conductor_state = "on",
 	mesecons = {conductor = {
 		state = mesecon.state.on,
 		offstate = "mesecons_extrawires:vertical_top_off",
 		rules = top_rules,
-	}}
+	}},
+	drop = "mesecons_extrawires:vertical_off",
+	after_place_node = vertical_update,
+	after_dig_node = vertical_update,
+})
+
+minetest.register_node("mesecons_extrawires:vertical_top_off", {
+	description = "Vertical mesecon",
+	drawtype = "nodebox",
+	tiles = {"wires_full_off.png","wires_full_off.png","wires_vertical_off.png"},
+	walkable = false,
+	paramtype = "light",
+	sunlight_propagates = true,
+	groups = {dig_immediate=3, not_in_creative_inventory=1},
+	selection_box = top_box,
+	node_box = top_box,
+	is_vertical_conductor = true,
+	vertical_conductor_state = "off",
+	mesecons = {conductor = {
+		state = mesecon.state.off,
+		onstate = "mesecons_extrawires:vertical_top_on",
+		rules = top_rules,
+	}},
+	drop = "mesecons_extrawires:vertical_off",
+	after_place_node = vertical_update,
+	after_dig_node = vertical_update,
 })
 
 -- Vertical wire bottom
-mesecon.register_node("mesecons_extrawires:vertical_bottom", {
+minetest.register_node("mesecons_extrawires:vertical_bottom_on", {
 	description = "Vertical mesecon",
 	drawtype = "nodebox",
+	tiles = {"wires_full_on.png","wires_full_on.png","wires_vertical_on.png"},
+	walkable = false,
+	paramtype = "light",
+	sunlight_propagates = true,
+	vertical_conductor_state = "on",
+	groups = {dig_immediate = 3, not_in_creative_inventory = 1},
+	selection_box = bottom_box,
+	node_box = bottom_box,
+	mesecons = {conductor = {
+		state = mesecon.state.on,
+		offstate = "mesecons_extrawires:vertical_bottom_off",
+		rules = bottom_rules,
+	}},
+	drop = "mesecons_extrawires:vertical_off",
+	after_place_node = vertical_update,
+	after_dig_node = vertical_update,
+})
+
+minetest.register_node("mesecons_extrawires:vertical_bottom_off", {
+	description = "Vertical mesecon",
+	drawtype = "nodebox",
+	tiles = {"wires_full_off.png","wires_full_off.png","wires_vertical_off.png"},
 	walkable = false,
 	paramtype = "light",
 	sunlight_propagates = true,
@@ -147,25 +187,15 @@ mesecon.register_node("mesecons_extrawires:vertical_bottom", {
 	selection_box = bottom_box,
 	node_box = bottom_box,
 	is_vertical_conductor = true,
-	drop = "mesecons_extrawires:vertical_off",
-	after_place_node = vertical_update,
-	after_dig_node = vertical_update
-},{
-	tiles = {"mesecons_wire_off.png"},
 	vertical_conductor_state = "off",
 	mesecons = {conductor = {
 		state = mesecon.state.off,
 		onstate = "mesecons_extrawires:vertical_bottom_on",
 		rules = bottom_rules,
-	}}
-},{
-	tiles = {"mesecons_wire_on.png"},
-	vertical_conductor_state = "on",
-	mesecons = {conductor = {
-		state = mesecon.state.on,
-		offstate = "mesecons_extrawires:vertical_bottom_off",
-		rules = bottom_rules,
-	}}
+	}},
+	drop = "mesecons_extrawires:vertical_off",
+	after_place_node = vertical_update,
+	after_dig_node = vertical_update,
 })
 
 minetest.register_craft({

mesecons_gates/init.lua

@@ -1,124 +1,222 @@
-local nodebox = {
-	type = "fixed",
-	fixed = {{-8/16, -8/16, -8/16, 8/16, -7/16, 8/16 }},
-}
-
-local function gate_rotate_rules(node, rules)
+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
 
-local function gate_get_output_rules(node)
-	return gate_rotate_rules(node, {{x=1, y=0, z=0}})
+function gate_get_output_rules(node)
+	rules = {{x=1, y=0, z=0}}
+	return gate_rotate_rules(node)
 end
 
-local function gate_get_input_rules_oneinput(node)
-	return gate_rotate_rules(node, {{x=-1, y=0, z=0}})
+function gate_get_input_rules_oneinput(node)
+	rules = {{x=-1, y=0, z=0}, {x=1, y=0, z=0}}
+	return gate_rotate_rules(node)
 end
 
-local function gate_get_input_rules_twoinputs(node)
-	return gate_rotate_rules(node, {{x=0, y=0, z=1, name="input1"},
-		{x=0, y=0, z=-1, name="input2"}})
+function gate_get_input_rules_twoinputs(node)
+	rules = {
+	{x=0, y=0, z=1},
+	{x=0, y=0, z=-1},
+	{x=1, y=0, z=0}}
+	return gate_rotate_rules(node)
 end
 
-local function set_gate(pos, node, state)
-	local gate = minetest.registered_nodes[node.name]
-
-	if mesecon.do_overheat(pos) then
-		minetest.remove_node(pos)
-		mesecon.receptor_off(pos, gate_get_output_rules(node))
-		minetest.add_item(pos, gate.drop)
-	elseif state then
-		minetest.swap_node(pos, {name = gate.onstate, param2=node.param2})
-		mesecon.receptor_on(pos, gate_get_output_rules(node))
-	else
-		minetest.swap_node(pos, {name = gate.offstate, param2=node.param2})
-		mesecon.receptor_off(pos, gate_get_output_rules(node))
+function update_gate(pos, node, rulename, newstate)
+	yc_update_real_portstates(pos, node, rulename, newstate)
+	gate = get_gate(pos)
+	L = rotate_ports(
+		yc_get_real_portstates(pos),
+		minetest.get_node(pos).param2
+	)
+	if gate == "diode" then
+		set_gate(pos, L.a)
+	elseif gate == "not" then
+		set_gate(pos, not L.a)
+	elseif gate == "nand" then
+		set_gate(pos, not(L.b and L.d))
+	elseif gate == "and" then
+		set_gate(pos, L.b and L.d)
+	elseif gate == "xor" then
+		set_gate(pos, (L.b and not L.d) or (not L.b and L.d))
 	end
 end
 
-local function update_gate(pos, node, link, newstate)
-	local gate = minetest.registered_nodes[node.name]
+function set_gate(pos, on)
+	gate = get_gate(pos)
+	local meta = minetest.get_meta(pos)
+	if on ~= gate_state(pos) then
+		if mesecon.do_overheat(pos) then
+			pop_gate(pos)
+		else
+			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,
+				gate_get_output_rules(node))
+			else
+				minetest.swap_node(pos, {name = "mesecons_gates:"..gate.."_off", param2=node.param2})
+				mesecon:receptor_off(pos,
+				gate_get_output_rules(node))
+			end
+		end
+	end
+end
 
+function get_gate(pos)
+	return minetest.registered_nodes[minetest.get_node(pos).name].mesecons_gate
+end
+
+function gate_state(pos)
+	name = minetest.get_node(pos).name
+	return string.find(name, "_on") ~= nil
+end
+
+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)
+	end , pos) -- wait for pending parsings
+	minetest.add_item(pos, "mesecons_gates:"..gate.."_off")
+end
+
+function rotate_ports(L, param2)
+	for rotations=0, param2-1 do
+		port = L.a
+		L.a = L.b
+		L.b = L.c
+		L.c = L.d
+		L.d = port
+	end
+	return L
+end
+
+gates = {
+{name = "diode", inputnumber = 1}, 
+{name = "not"  , inputnumber = 1}, 
+{name = "nand" , inputnumber = 2},
+{name = "and"  , inputnumber = 2},
+{name = "xor"  , inputnumber = 2}}
+
+local onoff, drop, nodename, description, groups
+for _, gate in ipairs(gates) do
 	if gate.inputnumber == 1 then
-		set_gate(pos, node, gate.assess(newstate == "on"))
+		get_rules = gate_get_input_rules_oneinput
 	elseif gate.inputnumber == 2 then
-		local meta = minetest.get_meta(pos)
-		meta:set_int(link.name, newstate == "on" and 1 or 0)
+		get_rules = gate_get_input_rules_twoinputs
+	end
+	for on = 0, 1 do
+		nodename = "mesecons_gates:"..gate.name
+		if on == 1 then
+			onoff = "on"
+			drop = nodename.."_off"
+			nodename = nodename.."_"..onoff
+			description = "You hacker you!"
+			groups = {dig_immediate=2, not_in_creative_inventory=1, overheat = 1}
+		else
+			onoff = "off"
+			drop = nil
+			nodename = nodename.."_"..onoff
+			description = gate.name.." Gate"
+			groups = {dig_immediate=2, overheat = 1}
+		end
 
-		local val1 = meta:get_int("input1") == 1
-		local val2 = meta:get_int("input2") == 1
-		set_gate(pos, node, gate.assess(val1, val2))
+		tiles = "jeija_microcontroller_bottom.png^"..
+			"jeija_gate_"..onoff..".png^"..
+			"jeija_gate_"..gate.name..".png"
+
+		node_box = {
+			type = "fixed",
+			fixed = {
+				{-8/16, -8/16, -8/16, 8/16, -7/16, 8/16 },
+			},
+		}
+
+		local mesecon_state
+		if on == 1 then
+			mesecon_state = mesecon.state.on
+		else
+			mesecon_state = mesecon.state.off
+		end
+
+		minetest.register_node(nodename, {
+			description = description,
+			paramtype = "light",
+			paramtype2 = "facedir",
+			drawtype = "nodebox",
+			tiles = {tiles},
+			inventory_image = tiles,
+			selection_box = node_box,
+			node_box = node_box,
+			walkable = true,
+			on_construct = function(pos)
+				local meta = minetest.get_meta(pos)
+				update_gate(pos)
+			end,
+			groups = groups,
+			drop = drop,
+			sounds = default.node_sound_stone_defaults(),
+			mesecons_gate = gate.name,
+			mesecons =
+			{
+				receptor =
+				{
+					state = mesecon_state,
+					rules = gate_get_output_rules
+				},
+				effector =
+				{
+					rules = get_rules,
+					action_change = update_gate
+				}
+			}
+		})
 	end
 end
 
-function register_gate(name, inputnumber, assess, recipe)
-	local get_inputrules = inputnumber == 2 and gate_get_input_rules_twoinputs or
-		gate_get_input_rules_oneinput
-	local description = "Mesecons Logic Gate: "..name
+minetest.register_craft({
+	output = 'mesecons_gates:diode_off',
+	recipe = {
+		{'', '', ''},
+		{'mesecons:mesecon', 'mesecons_torch:mesecon_torch_on', 'mesecons_torch:mesecon_torch_on'},
+		{'', '', ''},
+	},
+})
 
-	local basename = "mesecons_gates:"..name
-	mesecon.register_node(basename, {
-		description = description,
-		inventory_image = "jeija_gate_off.png^jeija_gate_"..name..".png",
-		paramtype = "light",
-		paramtype2 = "facedir",
-		drawtype = "nodebox",
-		drop = basename.."_off",
-		selection_box = nodebox,
-		node_box = nodebox,
-		walkable = true,
-		sounds = default.node_sound_stone_defaults(),
-		assess = assess,
-		onstate = basename.."_on",
-		offstate = basename.."_off",
-		inputnumber = inputnumber
-	},{
-		tiles = {"jeija_microcontroller_bottom.png^".."jeija_gate_off.png^"..
-			"jeija_gate_"..name..".png"},
-		groups = {dig_immediate = 2, overheat = 1},
-		mesecons = { receptor = {
-			state = "off",
-			rules = gate_get_output_rules
-		}, effector = {
-			rules = get_inputrules,
-			action_change = update_gate
-		}}
-	},{
-		tiles = {"jeija_microcontroller_bottom.png^".."jeija_gate_on.png^"..
-			"jeija_gate_"..name..".png"},
-		groups = {dig_immediate = 2, not_in_creative_inventory = 1, overheat = 1},
-		mesecons = { receptor = {
-			state = "on",
-			rules = gate_get_output_rules
-		}, effector = {
-			rules = get_inputrules,
-			action_change = update_gate
-		}}
-	})
+minetest.register_craft({
+	output = 'mesecons_gates:not_off',
+	recipe = {
+		{'', '', ''},
+		{'mesecons:mesecon', 'mesecons_torch:mesecon_torch_on', 'mesecons:mesecon'},
+		{'', '', ''},
+	},
+})
 
-	minetest.register_craft({output = basename.."_off", recipe = recipe})
-end
+minetest.register_craft({
+	output = 'mesecons_gates:and_off',
+	recipe = {
+		{'mesecons:mesecon', '', ''},
+		{'', 'mesecons_materials:silicon', 'mesecons:mesecon'},
+		{'mesecons:mesecon', '', ''},
+	},
+})
 
-register_gate("diode", 1, function (input) return input end,
-	{{"mesecons:mesecon", "mesecons_torch:mesecon_torch_on", "mesecons_torch:mesecon_torch_on"}})
+minetest.register_craft({
+	output = 'mesecons_gates:nand_off',
+	recipe = {
+		{'mesecons:mesecon', '', ''},
+		{'', 'mesecons_materials:silicon', 'mesecons_torch:mesecon_torch_on'},
+		{'mesecons:mesecon', '', ''},
+	},
+})
 
-register_gate("not", 1, function (input) return not input end,
-	{{"mesecons:mesecon", "mesecons_torch:mesecon_torch_on", "mesecons:mesecon"}})
-
-register_gate("and", 2, function (val1, val2) return val1 and val2 end,
-	{{"mesecons:mesecon", "", ""},
-	 {"", "mesecons_materials:silicon", "mesecons:mesecon"},
-	 {"mesecons:mesecon", "", ""}})
-
-register_gate("nand", 2, function (val1, val2) return not (val1 and val2) end,
-	{{"mesecons:mesecon", "", ""},
-	 {"", "mesecons_materials:silicon", "mesecons_torch:mesecon_torch_on"},
-	 {"mesecons:mesecon", "", ""}})
-
-register_gate("xor", 2, function (val1, val2) return (val1 or val2) and not (val1 and val2) end,
-	{{"mesecons:mesecon", "", ""},
-	 {"", "mesecons_materials:silicon", "mesecons_materials:silicon"},
-	 {"mesecons:mesecon", "", ""}})
+minetest.register_craft({
+	output = 'mesecons_gates:xor_off',
+	recipe = {
+		{'mesecons:mesecon', '', ''},
+		{'', 'mesecons_materials:silicon', 'mesecons_materials:silicon'},
+		{'mesecons:mesecon', '', ''},
+	},
+})

mesecons_hydroturbine/init.lua

@@ -4,17 +4,24 @@
 -- (does not work with other liquids)
 
 minetest.register_node("mesecons_hydroturbine:hydro_turbine_off", {
-	drawtype = "mesh",
-	mesh = "jeija_hydro_turbine.obj",
+	drawtype = "nodebox",
 	tiles = {"jeija_hydro_turbine_off.png"},
-	inventory_image = "jeija_hydro_turbine_inv.png",
-	wield_scale = {x=0.75, y=0.75, z=0.75},
 	groups = {dig_immediate=2},
     	description="Water Turbine",
 	paramtype = "light",
 	selection_box = {
 		type = "fixed",
-		fixed = { -0.5, -0.5, -0.5, 0.5, 1.5, 0.5 },
+		fixed = {{-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
+			{-0.15, 0.5, -0.15, 0.15, 1.45, 0.15},
+			{-0.45, 1.15, -0.1, 0.45, 1.45, 0.1},
+			{-0.1, 1.15, -0.45, 0.1, 1.45, 0.45}},
+	},
+	node_box = {
+		type = "fixed",
+		fixed = {{-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
+			{-0.15, 0.5, -0.15, 0.15, 1.45, 0.15},
+			{-0.45, 1.15, -0.1, 0.45, 1.45, 0.1},
+			{-0.1, 1.15, -0.45, 0.1, 1.45, 0.45}},
 	},
 	sounds = default.node_sound_stone_defaults(),
 	mesecons = {receptor = {
@@ -23,18 +30,25 @@ minetest.register_node("mesecons_hydroturbine:hydro_turbine_off", {
 })
 
 minetest.register_node("mesecons_hydroturbine:hydro_turbine_on", {
-	drawtype = "mesh",
-	mesh = "jeija_hydro_turbine.obj",
-	wield_scale = {x=0.75, y=0.75, z=0.75},
+	drawtype = "nodebox",
 	tiles = {"jeija_hydro_turbine_on.png"},
-	inventory_image = "jeija_hydro_turbine_inv.png",
 	drop = "mesecons_hydroturbine:hydro_turbine_off 1",
 	groups = {dig_immediate=2,not_in_creative_inventory=1},
 	description="Water Turbine",
 	paramtype = "light",
 	selection_box = {
 		type = "fixed",
-		fixed = { -0.5, -0.5, -0.5, 0.5, 1.5, 0.5 },
+		fixed = {{-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
+			{-0.15, 0.5, -0.15, 0.15, 1.45, 0.15},
+			{-0.5, 1.15, -0.1, 0.5, 1.45, 0.1},
+			{-0.1, 1.15, -0.5, 0.1, 1.45, 0.5}},
+	},
+	node_box = {
+		type = "fixed",
+		fixed = {{-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
+			{-0.15, 0.5, -0.15, 0.15, 1.45, 0.15},
+			{-0.5, 1.15, -0.1, 0.5, 1.45, 0.1},
+			{-0.1, 1.15, -0.5, 0.1, 1.45, 0.5}},
 	},
 	sounds = default.node_sound_stone_defaults(),
 	mesecons = {receptor = {
@@ -52,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,
 })
@@ -66,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,
 })

mesecons_hydroturbine/models/jeija_hydro_turbine.obj

@@ -1,416 +0,0 @@
-# Blender v2.69 (sub 0) OBJ File: 'mesecons-water-turbine.blend'
-# www.blender.org
-o Cylinder.002_Cylinder.003
-v 0.000000 0.500000 -0.150000
-v 0.000000 0.562500 -0.150000
-v 0.106066 0.500000 -0.106066
-v 0.106066 0.562500 -0.106066
-v 0.150000 0.500000 0.000000
-v 0.150000 0.562500 0.000000
-v 0.106066 0.500000 0.106066
-v 0.106066 0.562500 0.106066
-v -0.000000 0.500000 0.150000
-v -0.000000 0.562500 0.150000
-v -0.106066 0.500000 0.106066
-v -0.106066 0.562500 0.106066
-v -0.150000 0.500000 -0.000000
-v -0.150000 0.562500 -0.000000
-v -0.106066 0.500000 -0.106066
-v -0.106066 0.562500 -0.106066
-v 0.097545 0.625000 -0.490393
-v -0.097545 0.625000 -0.490393
-v -0.277785 0.625000 -0.415735
-v -0.415735 0.625000 -0.277785
-v -0.490393 0.625000 -0.097545
-v -0.490393 0.625000 0.097545
-v -0.415735 0.625000 0.277785
-v -0.277785 0.625000 0.415735
-v -0.097545 0.625000 0.490393
-v 0.097545 0.625000 0.490393
-v 0.277785 0.625000 0.415735
-v 0.415735 0.625000 0.277785
-v 0.490393 0.625000 0.097545
-v 0.490393 0.625000 -0.097545
-v 0.415735 0.625000 -0.277785
-v 0.277785 0.625000 -0.415735
-v 0.097545 0.656250 -0.490393
-v -0.097545 0.656250 -0.490393
-v -0.277785 0.656250 -0.415735
-v -0.415735 0.656250 -0.277785
-v -0.490393 0.656250 -0.097545
-v -0.490393 0.656250 0.097545
-v -0.415735 0.656250 0.277785
-v -0.277785 0.656250 0.415735
-v -0.097545 0.656250 0.490393
-v 0.097545 0.656250 0.490393
-v 0.277785 0.656250 0.415735
-v 0.415735 0.656250 0.277785
-v 0.490393 0.656250 0.097545
-v 0.490393 0.656250 -0.097545
-v 0.415735 0.656250 -0.277785
-v 0.277785 0.656250 -0.415735
-v 0.116233 0.634645 -0.436100
-v 0.116233 1.482640 -0.436100
-v 0.299524 0.634645 -0.186124
-v 0.299524 1.482640 -0.186124
-v 0.343405 0.634645 0.080186
-v 0.343405 1.482640 0.080186
-v 0.186124 0.634645 0.299524
-v 0.186124 1.482640 0.299524
-v -0.080186 0.634645 0.343405
-v -0.080186 1.482640 0.343405
-v -0.299524 0.634645 0.186124
-v -0.299524 1.482640 0.186124
-v -0.343405 0.634645 -0.080186
-v -0.343405 1.482640 -0.080186
-v -0.186124 0.634645 -0.299524
-v -0.186124 1.482640 -0.299524
-v 0.080186 0.634645 -0.343405
-v 0.080186 1.482640 -0.343405
-v 0.390559 1.482640 -0.226180
-v 0.390559 0.634645 -0.226180
-v 0.436100 1.482640 0.116233
-v 0.436100 0.634645 0.116233
-v 0.226180 1.482640 0.390559
-v 0.226180 0.634645 0.390559
-v -0.116233 1.482640 0.436100
-v -0.116233 0.634645 0.436100
-v -0.390559 1.482640 0.226180
-v -0.390559 0.634645 0.226180
-v -0.436100 1.482640 -0.116233
-v -0.436100 0.634645 -0.116233
-v -0.226180 1.482640 -0.390559
-v -0.226180 0.634645 -0.390559
-v 0.108975 0.634645 -0.430778
-v 0.292266 0.634645 -0.180802
-v 0.292266 1.482640 -0.180802
-v 0.108975 1.482640 -0.430778
-v 0.381664 0.634645 -0.227549
-v 0.334509 0.634645 0.078817
-v 0.334509 1.482640 0.078817
-v 0.381664 1.482640 -0.227549
-v 0.430778 0.634645 0.108975
-v 0.180802 0.634645 0.292266
-v 0.180802 1.482640 0.292266
-v 0.430778 1.482640 0.108975
-v 0.227549 0.634645 0.381664
-v -0.078817 0.634645 0.334509
-v -0.078817 1.482640 0.334509
-v 0.227549 1.482640 0.381664
-v -0.108975 0.634645 0.430778
-v -0.292266 0.634645 0.180802
-v -0.292266 1.482640 0.180802
-v -0.108975 1.482640 0.430778
-v -0.381664 0.634645 0.227549
-v -0.334509 0.634645 -0.078817
-v -0.334509 1.482640 -0.078817
-v -0.381664 1.482640 0.227549
-v -0.227549 0.634645 -0.381663
-v 0.078817 0.634645 -0.334509
-v 0.078817 1.482640 -0.334509
-v -0.227549 1.482640 -0.381663
-v -0.430779 0.634645 -0.108975
-v -0.180802 0.634645 -0.292266
-v -0.180802 1.482640 -0.292266
-v -0.430779 1.482640 -0.108975
-v 0.097545 1.500000 -0.490393
-v -0.097545 1.500000 -0.490393
-v -0.277785 1.500000 -0.415735
-v -0.415735 1.500000 -0.277785
-v -0.490393 1.500000 -0.097545
-v -0.490393 1.500000 0.097545
-v -0.415735 1.500000 0.277785
-v -0.277785 1.500000 0.415735
-v -0.097545 1.500000 0.490393
-v 0.097545 1.500000 0.490393
-v 0.277785 1.500000 0.415735
-v 0.415735 1.500000 0.277785
-v 0.490393 1.500000 0.097545
-v 0.490393 1.500000 -0.097545
-v 0.415735 1.500000 -0.277785
-v 0.277785 1.500000 -0.415735
-v 0.097545 1.468750 -0.490393
-v -0.097545 1.468750 -0.490393
-v -0.277785 1.468750 -0.415735
-v -0.415735 1.468750 -0.277785
-v -0.490393 1.468750 -0.097545
-v -0.490393 1.468750 0.097545
-v -0.415735 1.468750 0.277785
-v -0.277785 1.468750 0.415735
-v -0.097545 1.468750 0.490393
-v 0.097545 1.468750 0.490393
-v 0.277785 1.468750 0.415735
-v 0.415735 1.468750 0.277785
-v 0.490393 1.468750 0.097545
-v 0.490393 1.468750 -0.097545
-v 0.415735 1.468750 -0.277785
-v 0.277785 1.468750 -0.415735
-v 0.025624 0.559630 -0.061863
-v 0.025624 1.481372 -0.061863
-v 0.061863 0.559630 -0.025624
-v 0.061863 1.481372 -0.025624
-v 0.061863 0.559630 0.025624
-v 0.061863 1.481372 0.025624
-v 0.025624 0.559630 0.061863
-v 0.025624 1.481372 0.061863
-v -0.025624 0.559630 0.061863
-v -0.025624 1.481372 0.061863
-v -0.061863 0.559630 0.025624
-v -0.061863 1.481372 0.025624
-v -0.061863 0.559630 -0.025624
-v -0.061863 1.481372 -0.025624
-v -0.025624 0.559630 -0.061863
-v -0.025624 1.481372 -0.061863
-v 0.500000 -0.500000 -0.500000
-v 0.500000 -0.500000 0.500000
-v -0.500000 -0.500000 0.500000
-v -0.500000 -0.500000 -0.500000
-v 0.500000 0.500000 -0.500000
-v 0.500000 0.500000 0.500000
-v -0.500000 0.500000 0.500000
-v -0.500000 0.500000 -0.500000
-vt 0.416667 0.625000
-vt 0.416667 0.645833
-vt 0.395833 0.645833
-vt 0.395833 0.625000
-vt 0.375000 0.645833
-vt 0.375000 0.625000
-vt 0.291667 0.625000
-vt 0.291667 0.645833
-vt 0.312500 0.645833
-vt 0.312500 0.625000
-vt 0.333333 0.645833
-vt 0.333333 0.625000
-vt 0.354167 0.645833
-vt 0.354167 0.625000
-vt 0.708333 0.645833
-vt 0.729167 0.625000
-vt 0.750000 0.625000
-vt 0.770833 0.645833
-vt 0.770833 0.666667
-vt 0.750000 0.687500
-vt 0.729167 0.687500
-vt 0.708333 0.666667
-vt 0.437500 0.625000
-vt 0.437500 0.645833
-vt 0.458333 0.625000
-vt 0.458333 0.645833
-vt 0.656250 0.953125
-vt 0.593750 0.980469
-vt 0.531250 0.980469
-vt 0.468750 0.953125
-vt 0.421875 0.906250
-vt 0.394531 0.843750
-vt 0.394531 0.781250
-vt 0.421875 0.718750
-vt 0.468750 0.671875
-vt 0.531250 0.644531
-vt 0.593750 0.644531
-vt 0.656250 0.671875
-vt 0.703125 0.718750
-vt 0.730469 0.781250
-vt 0.730469 0.843750
-vt 0.703125 0.906250
-vt 0.019531 0.843750
-vt 0.019531 0.781250
-vt 0.046875 0.718750
-vt 0.093750 0.671875
-vt 0.156250 0.644531
-vt 0.218750 0.644531
-vt 0.281250 0.671875
-vt 0.328125 0.718750
-vt 0.355469 0.781250
-vt 0.355469 0.843750
-vt 0.328125 0.906250
-vt 0.281250 0.953125
-vt 0.218750 0.980469
-vt 0.156250 0.980469
-vt 0.093750 0.953125
-vt 0.046875 0.906250
-vt 0.187500 0.041667
-vt 0.104167 0.041667
-vt 0.104167 0.020833
-vt 0.187500 0.020833
-vt 0.270833 0.041667
-vt 0.270833 0.020833
-vt 0.354167 0.041667
-vt 0.354167 0.020833
-vt 0.437500 0.041667
-vt 0.437500 0.020833
-vt 0.520833 0.041667
-vt 0.520833 0.020833
-vt 0.354167 0.104167
-vt 0.270833 0.104167
-vt 0.270833 0.083333
-vt 0.354167 0.083333
-vt 0.604167 0.041667
-vt 0.604167 0.020833
-vt 0.687500 0.041667
-vt 0.687500 0.020833
-vt 0.437500 0.104167
-vt 0.437500 0.083333
-vt 0.104167 0.104167
-vt 0.020833 0.104167
-vt 0.020833 0.083333
-vt 0.104167 0.083333
-vt 0.520833 0.104167
-vt 0.520833 0.083333
-vt 0.187500 0.104167
-vt 0.187500 0.083333
-vt 0.604167 0.104167
-vt 0.604167 0.083333
-vt 0.687500 0.104167
-vt 0.687500 0.083333
-vt 0.020833 0.041667
-vt 0.020833 0.020833
-vt 0.979167 0.020833
-vt 0.979167 0.270833
-vt 0.895833 0.270833
-vt 0.895833 0.020833
-vt 0.875000 0.020833
-vt 0.875000 0.270833
-vt 0.791667 0.270833
-vt 0.791667 0.020833
-vt 0.687500 0.208333
-vt 0.687500 0.229167
-vt 0.604167 0.229167
-vt 0.604167 0.208333
-vt 0.104167 0.145833
-vt 0.104167 0.166667
-vt 0.020833 0.166667
-vt 0.020833 0.145833
-vt 0.187500 0.145833
-vt 0.187500 0.166667
-vt 0.270833 0.145833
-vt 0.270833 0.166667
-vt 0.354167 0.145833
-vt 0.354167 0.166667
-vt 0.187500 0.208333
-vt 0.187500 0.229167
-vt 0.104167 0.229167
-vt 0.104167 0.208333
-vt 0.437500 0.145833
-vt 0.437500 0.166667
-vt 0.520833 0.145833
-vt 0.520833 0.166667
-vt 0.270833 0.208333
-vt 0.270833 0.229167
-vt 0.604167 0.145833
-vt 0.604167 0.166667
-vt 0.354167 0.208333
-vt 0.354167 0.229167
-vt 0.687500 0.145833
-vt 0.687500 0.166667
-vt 0.437500 0.208333
-vt 0.437500 0.229167
-vt 0.020833 0.229167
-vt 0.020833 0.208333
-vt 0.520833 0.208333
-vt 0.520833 0.229167
-vt 0.854167 0.645833
-vt 0.854167 0.979167
-vt 0.812500 0.979167
-vt 0.812500 0.645833
-vt 0.979167 0.312500
-vt 0.979167 0.645833
-vt 0.937500 0.645833
-vt 0.937500 0.312500
-vt 0.895833 0.645833
-vt 0.895833 0.312500
-vt 0.854167 0.312500
-vt 0.812500 0.312500
-vt 0.979167 0.979167
-vt 0.937500 0.979167
-vt 0.895833 0.979167
-vt 0.020833 0.604167
-vt 0.020833 0.270833
-vt 0.354167 0.270833
-vt 0.354167 0.604167
-vt 0.729167 0.270833
-vt 0.729167 0.604167
-vt 0.395833 0.604167
-vt 0.395833 0.270833
-s off
-f 1/1 2/2 4/3 3/4
-f 3/4 4/3 6/5 5/6
-f 5/7 6/8 8/9 7/10
-f 7/10 8/9 10/11 9/12
-f 9/12 10/11 12/13 11/14
-f 11/14 12/13 14/5 13/6
-f 4/15 2/16 16/17 14/18 12/19 10/20 8/21 6/22
-f 15/23 16/24 2/2 1/1
-f 13/25 14/26 16/24 15/23
-f 130/27 129/28 144/29 143/30 142/31 141/32 140/33 139/34 138/35 137/36 136/37 135/38 134/39 133/40 132/41 131/42
-f 18/43 17/44 32/45 31/46 30/47 29/48 28/49 27/50 26/51 25/52 24/53 23/54 22/55 21/56 20/57 19/58
-f 27/59 28/60 44/61 43/62
-f 26/63 27/59 43/62 42/64
-f 25/65 26/63 42/64 41/66
-f 24/67 25/65 41/66 40/68
-f 23/69 24/67 40/68 39/70
-f 17/71 18/72 34/73 33/74
-f 22/75 23/69 39/70 38/76
-f 21/77 22/75 38/76 37/78
-f 32/79 17/71 33/74 48/80
-f 20/81 21/82 37/83 36/84
-f 31/85 32/79 48/80 47/86
-f 19/87 20/81 36/84 35/88
-f 30/89 31/85 47/86 46/90
-f 18/72 19/87 35/88 34/73
-f 29/91 30/89 46/90 45/92
-f 28/60 29/93 45/94 44/61
-f 49/95 50/96 52/97 51/98
-f 68/98 67/95 54/96 53/97
-f 70/95 69/96 56/97 55/98
-f 72/96 71/97 58/98 57/95
-f 74/95 73/96 60/97 59/98
-f 76/95 75/96 62/97 61/98
-f 80/96 79/97 66/98 65/95
-f 78/95 77/96 64/97 63/98
-f 81/99 82/100 83/101 84/102
-f 85/100 86/101 87/102 88/99
-f 89/101 90/102 91/99 92/100
-f 93/102 94/99 95/100 96/101
-f 97/102 98/99 99/100 100/101
-f 101/99 102/100 103/101 104/102
-f 105/102 106/99 107/100 108/101
-f 109/101 110/102 111/99 112/100
-f 75/100 76/99 101/98 104/97
-f 71/100 72/99 93/98 96/97
-f 67/98 68/97 85/100 88/99
-f 79/98 80/97 105/100 108/99
-f 77/100 78/99 109/98 112/97
-f 73/100 74/99 97/98 100/97
-f 69/98 70/97 89/100 92/99
-f 50/98 49/97 81/100 84/99
-f 33/51 34/52 35/53 36/54 37/55 38/56 39/57 40/58 41/43 42/44 43/45 44/46 45/47 46/48 47/49 48/50
-f 123/103 139/104 140/105 124/106
-f 122/107 138/108 139/109 123/110
-f 121/111 137/112 138/108 122/107
-f 120/113 136/114 137/112 121/111
-f 119/115 135/116 136/114 120/113
-f 113/117 129/118 130/119 114/120
-f 118/121 134/122 135/116 119/115
-f 117/123 133/124 134/122 118/121
-f 128/125 144/126 129/118 113/117
-f 116/127 132/128 133/124 117/123
-f 127/129 143/130 144/126 128/125
-f 115/131 131/132 132/128 116/127
-f 126/133 142/134 143/130 127/129
-f 114/120 130/119 131/135 115/136
-f 125/137 141/138 142/134 126/133
-f 124/106 140/105 141/138 125/137
-f 145/139 146/140 148/141 147/142
-f 147/143 148/144 150/145 149/146
-f 149/146 150/145 152/147 151/148
-f 151/148 152/147 154/139 153/149
-f 153/149 154/139 156/142 155/150
-f 155/144 156/151 158/152 157/145
-f 159/147 160/153 146/140 145/139
-f 157/145 158/152 160/153 159/147
-f 161/154 162/155 163/156 164/157
-f 165/155 168/156 167/157 166/154
-f 161/158 165/159 166/160 162/161
-f 162/158 166/159 167/160 163/161
-f 163/158 167/159 168/160 164/161
-f 165/160 161/161 164/158 168/159
-f 113/40 114/41 115/42 116/27 117/28 118/29 119/30 120/31 121/32 122/33 123/34 124/35 125/36 126/37 127/38 128/39

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
@@ -41,7 +41,7 @@ minetest.register_node("mesecons_insulated:insulated_on", {
 
 minetest.register_node("mesecons_insulated:insulated_off", {
 	drawtype = "nodebox",
-	description = "Insulated Mesecon",
+	description = "insulated mesecons",
 	tiles = {
 		"jeija_insulated_wire_sides_off.png",
 		"jeija_insulated_wire_sides_off.png",
@@ -78,3 +78,7 @@ minetest.register_craft({
 		{"mesecons_materials:fiber", "mesecons_materials:fiber", "mesecons_materials:fiber"},
 	}
 })
+
+mesecon:add_rules("insulated", {
+{x = 1,  y = 0,  z = 0},
+{x =-1,  y = 0,  z = 0}})

mesecons_lightstone/depends.txt

@@ -1,2 +1 @@
 mesecons
-dye

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", "dye:red", "jeija_lightstone_red_off.png", "jeija_lightstone_red_on.png")
-mesecon.lightstone_add("green", "dye:green", "jeija_lightstone_green_off.png", "jeija_lightstone_green_on.png")
-mesecon.lightstone_add("blue", "dye:blue", "jeija_lightstone_blue_off.png", "jeija_lightstone_blue_on.png")
-mesecon.lightstone_add("gray", "dye:grey", "jeija_lightstone_gray_off.png", "jeija_lightstone_gray_on.png")
-mesecon.lightstone_add("darkgray", "dye:dark_grey", "jeija_lightstone_darkgray_off.png", "jeija_lightstone_darkgray_on.png")
-mesecon.lightstone_add("yellow", "dye:yellow", "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")

mesecons_luacontroller/init.lua

@@ -1,21 +1,11 @@
---        ______
---       |
---       |
---       |        __       ___  _   __         _  _
--- |   | |       |  | |\ |  |  |_| |  | |  |  |_ |_|
--- |___| |______ |__| | \|  |  | \ |__| |_ |_ |_ |\
--- |
--- |
---
-
 -- Reference
--- ports = get_real_port_states(pos): gets if inputs are powered from outside
--- newport = merge_port_states(state1, state2): just does result = state1 or state2 for every port
--- set_port(pos, rule, state): activates/deactivates the mesecons according to the port states
--- set_port_states(pos, ports): Applies new port states to a LuaController at pos
--- run(pos): runs the code in the controller at pos
--- reset_meta(pos, code, errmsg): performs a software-reset, installs new code and prints error messages
--- resetn(pos): performs a hardware reset, turns off all ports
+-- ports = get_real_portstates(pos): gets if inputs are powered from outside
+-- newport = merge_portstates(state1, state2): just does result = state1 or state2 for every port
+-- action_setports(pos, rule, state): activates/deactivates the mesecons according to the portstates (helper for action)
+-- action(pos, ports): Applies new portstates to a luacontroller at pos
+-- lc_update(pos): updates the controller at pos by executing the code
+-- reset_meta (pos, code, errmsg): performs a software-reset, installs new code and prints error messages
+-- reset (pos): performs a hardware reset, turns off all ports
 --
 -- The Sandbox
 -- The whole code of the controller runs in a sandbox,
@@ -30,76 +20,70 @@
 
 local BASENAME = "mesecons_luacontroller:luacontroller"
 
-local rules = {
-	a = {x = -1, y = 0, z =  0, name="A"},
-	b = {x =  0, y = 0, z =  1, name="B"},
-	c = {x =  1, y = 0, z =  0, name="C"},
-	d = {x =  0, y = 0, z = -1, name="D"},
-}
-
+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"}
 
 ------------------
 -- Action stuff --
 ------------------
--- These helpers are required to set the port states of the luacontroller
+-- These helpers are required to set the portstates of the luacontroller
 
-local function update_real_port_states(pos, rule_name, new_state)
+function lc_update_real_portstates(pos, rulename, newstate)
 	local meta = minetest.get_meta(pos)
-	if rule_name == nil then
+	if rulename == nil then
 		meta:set_int("real_portstates", 1)
 		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
-		n = math.floor(n / 2)
+		L[i] = n%2
+		n = math.floor(n/2)
 	end
-	--                   (0,-1) (-1,0)      (1,0) (0,1)
-	local pos_to_side = {  4,     1,   nil,   3,    2 }
-	if rule_name.x == nil then
-		for _, rname in ipairs(rule_name) do
-			local port = pos_to_side[rname.x + (2 * rname.z) + 3]
+	if rulename.x == nil then
+		for _, rname in ipairs(rulename) do
+			local port = ({4, 1, nil, 3, 2})[rname.x+2*rname.z+3]
 			L[port] = (newstate == "on") and 1 or 0
 		end
 	else
-		local port = pos_to_side[rule_name.x + (2 * rule_name.z) + 3]
-		L[port] = (new_state == "on") and 1 or 0
+		local port = ({4, 1, nil, 3, 2})[rulename.x+2*rulename.z+3]
+		L[port] = (newstate == "on") and 1 or 0
 	end
-	meta:set_int("real_portstates",
-		1 +
-		1 * L[1] +
-		2 * L[2] +
-		4 * L[3] +
-		8 * L[4])
+	meta:set_int("real_portstates", 1 + L[1] + 2*L[2] + 4*L[3] + 8*L[4])
 end
 
-
-local port_names = {"a", "b", "c", "d"}
-
-local function get_real_port_states(pos)
-	-- Determine if ports are powered (by itself or from outside)
+local get_real_portstates = function(pos) -- determine if ports are powered (by itself or from outside)
 	local meta = minetest.get_meta(pos)
 	local L = {}
 	local n = meta:get_int("real_portstates") - 1
-	for _, name in ipairs(port_names) do
-		L[name] = ((n % 2) == 1)
-		n = math.floor(n / 2)
+	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)
 	end
 	return L
 end
 
-
-local function merge_port_states(ports, vports)
-	return {
-		a = ports.a or vports.a,
-		b = ports.b or vports.b,
-		c = ports.c or vports.c,
-		d = ports.d or vports.d,
-	}
+local merge_portstates = function (ports, vports)
+	local npo = {a=false, b=false, c=false, d=false}
+	npo.a = vports.a or ports.a
+	npo.b = vports.b or ports.b
+	npo.c = vports.c or ports.c
+	npo.d = vports.d or ports.d
+	return npo
 end
 
-local function generate_name(ports)
+local generate_name = function (ports)
+	local overwrite = overwrite or {}
 	local d = ports.d and 1 or 0
 	local c = ports.c and 1 or 0
 	local b = ports.b and 1 or 0
@@ -107,136 +91,101 @@ local function generate_name(ports)
 	return BASENAME..d..c..b..a
 end
 
-
-local function set_port(pos, rule, state)
+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
 
-
-local function clean_port_states(ports)
-	ports.a = ports.a and true or false
-	ports.b = ports.b and true or false
-	ports.c = ports.c and true or false
-	ports.d = ports.d and true or false
-end
-
-
-local function set_port_states(pos, ports)
+local action = function (pos, ports)
 	local node = minetest.get_node(pos)
 	local name = node.name
-	clean_port_states(ports)
 	local vports = minetest.registered_nodes[name].virtual_portstates
-	local new_name = generate_name(ports)
+	local newname = generate_name(ports)
 
-	if name ~= new_name and vports then
-		-- Problem:
-		-- We need to place the new node first so that when turning
-		-- off some port, it won't stay on because the rules indicate
-		-- there is an onstate output port there.
-		-- When turning the output off then, it will however cause feedback
-		-- so that the luacontroller will receive an "off" event by turning
-		-- its output off.
-		-- Solution / Workaround:
-		-- Remember which output was turned off and ignore next "off" event.
-		local meta = minetest.get_meta(pos)
-		local ign = minetest.deserialize(meta:get_string("ignore_offevents")) or {}
-		if ports.a and not vports.a and not mesecon.is_powered(pos, rules.a) then ign.A = true end
-		if ports.b and not vports.b and not mesecon.is_powered(pos, rules.b) then ign.B = true end
-		if ports.c and not vports.c and not mesecon.is_powered(pos, rules.c) then ign.C = true end
-		if ports.d and not vports.d and not mesecon.is_powered(pos, rules.d) then ign.D = true end
-		meta:set_string("ignore_offevents", minetest.serialize(ign))
+	if name ~= newname and vports then
+		local rules_on  = {}
+		local rules_off = {}
 
-		minetest.swap_node(pos, {name = new_name, param2 = node.param2})
+		minetest.swap_node(pos, {name = newname, param2 = node.param2})
 
-		if ports.a ~= vports.a then set_port(pos, rules.a, ports.a) end
-		if ports.b ~= vports.b then set_port(pos, rules.b, ports.b) end
-		if ports.c ~= vports.c then set_port(pos, rules.c, ports.c) end
-		if ports.d ~= vports.d then set_port(pos, rules.d, ports.d) end
+		if ports.a ~= vports.a then setport(pos, rules.a, ports.a) end
+		if ports.b ~= vports.b then setport(pos, rules.b, ports.b) end
+		if ports.c ~= vports.c then setport(pos, rules.c, ports.c) end
+		if ports.d ~= vports.d then setport(pos, rules.d, ports.d) end
 	end
 end
 
+--------------------
+-- Overheat stuff --
+--------------------
 
------------------
--- Overheating --
------------------
-
-local function overheat_off(pos)
-	mesecon.receptor_off(pos, mesecon.rules.flat)
+local overheat_off = function(pos)
+	mesecon:receptor_off(pos, mesecon.rules.flat)
 end
 
+-------------------
+-- Parsing stuff --
+-------------------
 
-local function overheat(pos, meta)
-	if mesecon.do_overheat(pos) then -- If too hot
-		local node = minetest.get_node(pos)
-		node.name = BASENAME.."_burnt"
-		minetest.swap_node(pos, node)
-		-- Wait for pending operations
-		minetest.after(0.2, overheat_off, pos)
-		return true
+local code_prohibited = function(code)
+	-- Clean code
+	local prohibited = {"while", "for", "repeat", "until", "function", "goto"}
+	for _, p in ipairs(prohibited) do
+		if string.find(code, p) then
+			return "Prohibited command: "..p
+		end
 	end
 end
 
-------------------------
--- Ignored off events --
-------------------------
-
-local function ignore_event(event, meta)
-	if event.type ~= "off" then return false end
-	local ignore_offevents = minetest.deserialize(meta:get_string("ignore_offevents")) or {}
-	if ignore_offevents[event.pin.name] then
-		ignore_offevents[event.pin.name] = nil
-		meta:set_string("ignore_offevents", minetest.serialize(ignore_offevents))
-		return true
-	end
-end
-
--------------------------
--- Parsing and running --
--------------------------
-
-local function safe_print(param)
+local safe_print = function(param)
 	print(dump(param))
 end
 
-local function remove_functions(x)
-	local tp = type(x)
-	if tp == "table" then
-		for key, value in pairs(x) do
-			local key_t, val_t = type(key), type(value)
-			if key_t == "function" or val_t == "function" then
-				x[key] = nil
-			else
-				if key_t == "table" then
-					remove_functions(key)
-				end
-				if val_t == "table" then
-					remove_functions(value)
-				end
-			end
-		end
-	elseif tp == "function" then
-		return nil
+deep_copy = function(original, visited) --deep copy that removes functions
+	visited = visited or {}
+	if visited[original] ~= nil then --already visited this node
+		return visited[original]
+	end
+	if type(original) == 'table' then --nested table
+		local copy = {}
+		visited[original] = copy
+		for key, value in next, original, nil do
+			copy[deep_copy(key, visited)] = deep_copy(value, visited)
+		end
+		setmetatable(copy, deep_copy(getmetatable(original), visited))
+		return copy
+	elseif type(original) == 'function' then --ignore functions
+		return nil
+	else --by-value type
+		return original
 	end
-	return x
 end
 
-local function get_interrupt(pos)
-	-- iid = interrupt id
-	local function interrupt(time, iid)
+local safe_serialize = function(value)
+	return minetest.serialize(deep_copy(value))
+end
+
+mesecon.queue:add_function("lc_interrupt", function (pos, iid, luac_id)
+	-- There is no luacontroller anymore / it has been reprogrammed / replaced
+	if (minetest.get_meta(pos):get_int("luac_id") ~= luac_id) then return end
+	lc_update(pos, {type="interrupt", iid = iid})
+end)
+
+local getinterrupt = function(pos)
+	local interrupt = function (time, iid) -- iid = interrupt id
 		if type(time) ~= "number" then return end
-		local luac_id = minetest.get_meta(pos):get_int("luac_id")
-		mesecon.queue:add_action(pos, "lc_interrupt", {luac_id, iid}, time, iid, 1)
+		luac_id = minetest.get_meta(pos):get_int("luac_id")
+		mesecon.queue:add_action(pos, "lc_interrupt", {iid, luac_id}, time, iid, 1)
 	end
 	return interrupt
 end
 
-
-local function get_digiline_send(pos)
+local getdigiline_send = function(pos)
 	if not digiline then return end
+	-- Send messages on next serverstep
 	return function(channel, msg)
 		minetest.after(0, function()
 			digiline:receptor_send(pos, digiline.rules.default, channel, msg)
@@ -244,187 +193,145 @@ local function get_digiline_send(pos)
 	end
 end
 
-
-local safe_globals = {
-	"assert", "error", "ipairs", "next", "pairs", "pcall", "select",
-	"tonumber", "tostring", "type", "unpack", "_VERSION", "xpcall", 
-}
-local function create_environment(pos, mem, event)
+local create_environment = function(pos, mem, event)
 	-- Gather variables for the environment
 	local vports = minetest.registered_nodes[minetest.get_node(pos).name].virtual_portstates
-	local vports_copy = {}
-	for k, v in pairs(vports) do vports_copy[k] = v end
-	local rports = get_real_port_states(pos)
+	vports = {a = vports.a, b = vports.b, c = vports.c, d = vports.d}
+	local rports = get_real_portstates(pos)
 
-	-- Create new library tables on each call to prevent one LuaController
-	-- from breaking a library and messing up other LuaControllers.
-	local env = {
-		pin = merge_port_states(vports, rports),
-		port = vports_copy,
-		event = event,
-		mem = mem,
-		heat = minetest.get_meta(pos):get_int("heat"),
-		heat_max = mesecon.setting("overheat_max", 20),
-		print = safe_print,
-		interrupt = get_interrupt(pos),
-		digiline_send = get_digiline_send(pos),
-		string = {
-			byte = string.byte,
-			char = string.char,
-			format = string.format,
-			gsub = string.gsub,
-			len = string.len,
-			lower = string.lower,
-			upper = string.upper,
-			rep = string.rep,
-			reverse = string.reverse,
-			sub = string.sub,
-		},
-		math = {
-			abs = math.abs,
-			acos = math.acos,
-			asin = math.asin,
-			atan = math.atan,
-			atan2 = math.atan2,
-			ceil = math.ceil,
-			cos = math.cos,
-			cosh = math.cosh,
-			deg = math.deg,
-			exp = math.exp,
-			floor = math.floor,
-			fmod = math.fmod,
-			frexp = math.frexp,
-			huge = math.huge,
-			ldexp = math.ldexp,
-			log = math.log,
-			log10 = math.log10,
-			max = math.max,
-			min = math.min,
-			modf = math.modf,
-			pi = math.pi,
-			pow = math.pow,
-			rad = math.rad,
-			random = math.random,
-			sin = math.sin,
-			sinh = math.sinh,
-			sqrt = math.sqrt,
-			tan = math.tan,
-			tanh = math.tanh,
-		},
-		table = {
-			concat = table.concat,
-			insert = table.insert,
-			maxn = table.maxn,
-			remove = table.remove,
-			sort = table.sort,
-		},
-		os = {
-			clock = os.clock,
-			difftime = os.difftime,
-			time = os.time,
-		},
+	return {
+			print = safe_print,
+			pin = merge_portstates(vports, rports),
+			port = vports,
+			interrupt = getinterrupt(pos),
+			digiline_send = getdigiline_send(pos),
+			mem = mem,
+			tostring = tostring,
+			tonumber = tonumber,
+			heat = minetest.get_meta(pos):get_int("heat"),
+			heat_max = OVERHEAT_MAX,
+			string = {
+				byte = string.byte,
+				char = string.char,
+				find = string.find,
+				format = string.format,
+				gmatch = string.gmatch,
+				gsub = string.gsub,
+				len = string.len,
+				lower = string.lower,
+				upper = string.upper,
+				match = string.match,
+				rep = string.rep,
+				reverse = string.reverse,
+				sub = string.sub,
+			},
+			math = {
+				abs = math.abs,
+				acos = math.acos,
+				asin = math.asin,
+				atan = math.atan,
+				atan2 = math.atan2,
+				ceil = math.ceil,
+				cos = math.cos,
+				cosh = math.cosh,
+				deg = math.deg,
+				exp = math.exp,
+				floor = math.floor,
+				fmod = math.fmod,
+				frexp = math.frexp,
+				huge = math.huge,
+				ldexp = math.ldexp,
+				log = math.log,
+				log10 = math.log10,
+				max = math.max,
+				min = math.min,
+				modf = math.modf,
+				pi = math.pi,
+				pow = math.pow,
+				rad = math.rad,
+				random = math.random,
+				sin = math.sin,
+				sinh = math.sinh,
+				sqrt = math.sqrt,
+				tan = math.tan,
+				tanh = math.tanh,
+			},
+			table = {
+				insert = table.insert,
+				maxn = table.maxn,
+				remove = table.remove,
+				sort = table.sort
+			},
+			event = event,
 	}
-	env._G = env
-
-	for _, name in pairs(safe_globals) do
-		env[name] = _G[name]
-	end
-
-	return env
 end
 
-
-local function timeout()
-	debug.sethook()  -- Clear hook
-	error("Code timed out!")
-end
-
-
-local function code_prohibited(code)
-	-- LuaJIT doesn't increment the instruction counter when running
-	-- loops, so we have to sanitize inputs if we're using LuaJIT.
-	if not jit then
-		return false
-	end
-	local prohibited = {"while", "for", "do", "repeat", "until", "goto"}
-	code = " "..code.." "
-	for _, p in ipairs(prohibited) do
-		if string.find(code, "[^%w_]"..p.."[^%w_]") then
-			return "Prohibited command: "..p
-		end
-	end
-end
-
-
-local function create_sandbox(code, env)
+local create_sandbox = function (code, env)
+	-- Create Sandbox
 	if code:byte(1) == 27 then
-		return nil, "Binary code prohibited."
+		return _, "You Hacker You! Don't use binary code!"
 	end
-	local f, msg = loadstring(code)
-	if not f then return nil, msg end
+	f, msg = loadstring(code)
+	if not f then return _, msg end
 	setfenv(f, env)
+	return f
+end
 
-	return function(...)
-		debug.sethook(timeout, "", 10000)
-		local ok, ret = pcall(f, ...)
-		debug.sethook()  -- Clear hook
-		if not ok then error(ret) end
-		return ret
+local lc_overheat = function (pos, meta)
+	if mesecon.do_overheat(pos) then -- if too hot
+		local node = minetest.get_node(pos)
+		minetest.swap_node(pos, {name = BASENAME.."_burnt", param2 = node.param2})
+		minetest.after(0.2, overheat_off, pos) -- wait for pending operations
+		return true
 	end
 end
 
-
-local function load_memory(meta)
+local load_memory = function(meta)
 	return minetest.deserialize(meta:get_string("lc_memory")) or {}
 end
 
-
-local function save_memory(meta, mem)
-	meta:set_string("lc_memory",
-		minetest.serialize(
-			remove_functions(mem)
-		)
-	)
+local save_memory = function(meta, mem)
+	meta:set_string("lc_memory", safe_serialize(mem))
 end
 
+local ports_invalid = function (var)
+	if type(var) == "table" then
+		return false
+	end
+	return "The ports you set are invalid"
+end
 
-local function run(pos, event)
+----------------------
+-- Parsing function --
+----------------------
+
+lc_update = function (pos, event)
 	local meta = minetest.get_meta(pos)
-	if overheat(pos) then return end
-	if ignore_event(event, meta) then return end
+	if lc_overheat(pos) then return end
 
-	-- Load code & mem from meta
+	-- load code & mem from memory
 	local mem  = load_memory(meta)
 	local code = meta:get_string("code")
 
-	local err = code_prohibited(code)
-	if err then return err end
-
-	-- Create environment
+	-- make sure code is ok and create environment
+	local prohibited = code_prohibited(code)
+	if prohibited then return prohibited end
 	local env = create_environment(pos, mem, event)
 
-	-- Create the sandbox and execute code
-	local f, msg = create_sandbox(code, env)
-	if not f then return msg end
+	-- create the sandbox and execute code
+	local chunk, msg = create_sandbox (code, env)
+	if not chunk then return msg end
 	local success, msg = pcall(f)
 	if not success then return msg end
-	if type(env.port) ~= "table" then
-		return "Ports set are invalid."
-	end
+	if ports_invalid(env.port) then return ports_invalid(env.port) end
 
-	save_memory(meta, env.mem)
+	save_memory(meta, mem)
 
 	-- Actually set the ports
-	set_port_states(pos, env.port)
+	action(pos, env.port)
 end
 
-mesecon.queue:add_function("lc_interrupt", function (pos, luac_id, iid)
-	-- There is no luacontroller anymore / it has been reprogrammed / replaced
-	if (minetest.get_meta(pos):get_int("luac_id") ~= luac_id) then return end
-	run(pos, {type="interrupt", iid = iid})
-end)
-
-local function reset_meta(pos, code, errmsg)
+local reset_meta = function(pos, code, errmsg)
 	local meta = minetest.get_meta(pos)
 	meta:set_string("code", code)
 	code = minetest.formspec_escape(code or "")
@@ -436,154 +343,173 @@ local function reset_meta(pos, code, errmsg)
 		"image_button_exit[9.72,-0.25;0.425,0.4;jeija_close_window.png;exit;]"..
 		"label[0.1,5;"..errmsg.."]")
 	meta:set_int("heat", 0)
-	meta:set_int("luac_id", math.random(1, 65535))
+	meta:set_int("luac_id", math.random(1, 1000000))
 end
 
-local function reset(pos)
-	set_port_states(pos, {a=false, b=false, c=false, d=false})
+local reset = function (pos)
+	action(pos, {a=false, b=false, c=false, d=false})
 end
 
+--        ______
+--       |
+--       |
+--       |        __       ___  _   __         _  _
+-- |   | |       |  | |\ |  |  |_| |  | |  |  |_ |_|
+-- |___| |______ |__| | \|  |  | \ |__| |_ |_ |_ |\
+-- |
+-- |
+--
 
 -----------------------
 -- Node Registration --
 -----------------------
 
-local output_rules = {}
-local input_rules = {}
+local output_rules={}
+local input_rules={}
 
-local node_box = {
-	type = "fixed",
-	fixed = {
-		{-8/16, -8/16, -8/16, 8/16, -7/16, 8/16}, -- Bottom slab
-		{-5/16, -7/16, -5/16, 5/16, -6/16, 5/16}, -- Circuit board
-		{-3/16, -6/16, -3/16, 3/16, -5/16, 3/16}, -- IC
+local nodebox = {
+		type = "fixed",
+		fixed = {
+			{ -8/16, -8/16, -8/16, 8/16, -7/16, 8/16 }, -- bottom slab
+			{ -5/16, -7/16, -5/16, 5/16, -6/16, 5/16 }, -- circuit board
+			{ -3/16, -6/16, -3/16, 3/16, -5/16, 3/16 }, -- IC
+		}
 	}
-}
 
-local selection_box = {
-	type = "fixed",
-	fixed = { -8/16, -8/16, -8/16, 8/16, -5/16, 8/16 },
-}
+local selectionbox = {
+		type = "fixed",
+		fixed = { -8/16, -8/16, -8/16, 8/16, -5/16, 8/16 },
+	}
 
 local digiline = {
 	receptor = {},
 	effector = {
-		action = function(pos, node, channel, msg)
-			run(pos, {type = "digiline", channel = channel, msg = msg})
+		action = function (pos, node, channel, msg)
+			lc_update (pos, {type = "digiline", channel = channel, msg = msg})
 		end
 	}
 }
-local function on_receive_fields(pos, form_name, fields)
-	if not fields.program then
-		return
-	end
-	reset(pos)
-	reset_meta(pos, fields.code)
-	local err = run(pos, {type="program"})
-	if err then
-		print(err)
-		reset_meta(pos, fields.code, err)
-	end
-end
 
-for a = 0, 1 do -- 0 = off  1 = on
+for a = 0, 1 do -- 0 = off; 1 = on
 for b = 0, 1 do
 for c = 0, 1 do
 for d = 0, 1 do
-	local cid = tostring(d)..tostring(c)..tostring(b)..tostring(a)
-	local node_name = BASENAME..cid
-	local top = "jeija_luacontroller_top.png"
-	if a == 1 then
-		top = top.."^jeija_luacontroller_LED_A.png"
-	end
-	if b == 1 then
-		top = top.."^jeija_luacontroller_LED_B.png"
-	end
-	if c == 1 then
-		top = top.."^jeija_luacontroller_LED_C.png"
-	end
-	if d == 1 then
-		top = top.."^jeija_luacontroller_LED_D.png"
-	end
 
-	local groups
-	if a + b + c + d ~= 0 then
-		groups = {dig_immediate=2, not_in_creative_inventory=1, overheat = 1}
-	else
-		groups = {dig_immediate=2, overheat = 1}
-	end
+local cid = tostring(d)..tostring(c)..tostring(b)..tostring(a)
+local nodename = BASENAME..cid
+local top = "jeija_luacontroller_top.png"
+if a == 1 then
+	top = top.."^jeija_luacontroller_LED_A.png"
+end
+if b == 1 then
+	top = top.."^jeija_luacontroller_LED_B.png"
+end
+if c == 1 then
+	top = top.."^jeija_luacontroller_LED_C.png"
+end
+if d == 1 then
+	top = top.."^jeija_luacontroller_LED_D.png"
+end
 
-	output_rules[cid] = {}
-	input_rules[cid] = {}
-	if a == 1 then table.insert(output_rules[cid], rules.a) end
-	if b == 1 then table.insert(output_rules[cid], rules.b) end
-	if c == 1 then table.insert(output_rules[cid], rules.c) end
-	if d == 1 then table.insert(output_rules[cid], rules.d) end
+if a + b + c + d ~= 0 then
+	groups = {dig_immediate=2, not_in_creative_inventory=1, overheat = 1}
+else
+	groups = {dig_immediate=2, overheat = 1}
+end
 
-	if a == 0 then table.insert( input_rules[cid], rules.a) end
-	if b == 0 then table.insert( input_rules[cid], rules.b) end
-	if c == 0 then table.insert( input_rules[cid], rules.c) end
-	if d == 0 then table.insert( input_rules[cid], rules.d) end
+output_rules[cid] = {}
+input_rules[cid] = {}
+if (a == 1) then table.insert(output_rules[cid], rules.a) end
+if (b == 1) then table.insert(output_rules[cid], rules.b) end
+if (c == 1) then table.insert(output_rules[cid], rules.c) end
+if (d == 1) then table.insert(output_rules[cid], rules.d) end
 
-	local mesecons = {
-		effector = {
-			rules = input_rules[cid],
-			action_change = function (pos, _, rule_name, new_state)
-				update_real_port_states(pos, rule_name, new_state)
-				run(pos, {type=new_state, pin=rule_name})
-			end,
-		},
-		receptor = {
-			state = mesecon.state.on,
-			rules = output_rules[cid]
-		}
-	}
+if (a == 0) then table.insert(input_rules[cid], rules.a) end
+if (b == 0) then table.insert(input_rules[cid], rules.b) end
+if (c == 0) then table.insert(input_rules[cid], rules.c) end
+if (d == 0) then table.insert(input_rules[cid], rules.d) end
 
-	minetest.register_node(node_name, {
-		description = "LuaController",
-		drawtype = "nodebox",
-		tiles = {
-			top,
-			"jeija_microcontroller_bottom.png",
-			"jeija_microcontroller_sides.png",
-			"jeija_microcontroller_sides.png",
-			"jeija_microcontroller_sides.png",
-			"jeija_microcontroller_sides.png"
-		},
-		inventory_image = top,
-		paramtype = "light",
-		groups = groups,
-		drop = BASENAME.."0000",
-		sunlight_propagates = true,
-		selection_box = selection_box,
-		node_box = node_box,
-		on_construct = reset_meta,
-		on_receive_fields = on_receive_fields,
-		sounds = default.node_sound_stone_defaults(),
-		mesecons = mesecons,
-		digiline = digiline,
-		-- Virtual portstates are the ports that
-		-- the node shows as powered up (light up).
-		virtual_portstates = {
-			a = a == 1,
-			b = b == 1,
-			c = c == 1,
-			d = d == 1,
-		},
-		after_dig_node = function (pos, node)
-			mesecon.receptor_off(pos, output_rules)
+local mesecons = {
+	effector =
+	{
+		rules = input_rules[cid],
+		action_change = function (pos, _, rulename, newstate)
+			lc_update_real_portstates(pos, rulename, newstate)
+			lc_update(pos, {type=newstate,  pin=rulename})
 		end,
-		is_luacontroller = true,
-	})
+	},
+	receptor =
+	{
+		state = mesecon.state.on,
+		rules = output_rules[cid]
+	}
+}
+
+minetest.register_node(nodename, {
+	description = "Luacontroller",
+	drawtype = "nodebox",
+	tiles = {
+		top,
+		"jeija_microcontroller_bottom.png",
+		"jeija_microcontroller_sides.png",
+		"jeija_microcontroller_sides.png",
+		"jeija_microcontroller_sides.png",
+		"jeija_microcontroller_sides.png"
+		},
+
+	inventory_image = top,
+	paramtype = "light",
+	groups = groups,
+	drop = BASENAME.."0000",
+	sunlight_propagates = true,
+	selection_box = selectionbox,
+	node_box = nodebox,
+	on_construct = reset_meta,
+	on_receive_fields = function(pos, formname, fields)
+		if not fields.program then
+			return
+		end
+		reset(pos)
+		reset_meta(pos, fields.code)
+		local err = lc_update(pos, {type="program"})
+		if err then
+			print(err)
+			reset_meta(pos, fields.code, err)
+		end
+	end,
+	on_timer = handle_timer,
+	sounds = default.node_sound_stone_defaults(),
+	mesecons = mesecons,
+	digiline = digiline,
+	virtual_portstates = {	a = a == 1, -- virtual portstates are
+				b = b == 1, -- the ports the the
+				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)
+	end,
+	is_luacontroller = true,
+})
 end
 end
 end
 end
 
 ------------------------------
--- Overheated LuaController --
+-- overheated luacontroller --
 ------------------------------
 
+local mesecons_burnt = {
+	effector =
+	{
+		rules = mesecon.rules.flat,
+		action_change = function (pos, _, rulename, newstate)
+			-- only update portstates when changes are triggered
+			lc_update_real_portstates(pos, rulename, newstate)
+		end
+	}
+}
+
 minetest.register_node(BASENAME .. "_burnt", {
 	drawtype = "nodebox",
 	tiles = {
@@ -599,20 +525,24 @@ minetest.register_node(BASENAME .. "_burnt", {
 	groups = {dig_immediate=2, not_in_creative_inventory=1},
 	drop = BASENAME.."0000",
 	sunlight_propagates = true,
-	selection_box = selection_box,
-	node_box = node_box,
+	selection_box = selectionbox,
+	node_box = nodebox,
 	on_construct = reset_meta,
-	on_receive_fields = on_receive_fields,
+	on_receive_fields = function(pos, formname, fields)
+		if fields.quit then
+			return
+		end
+		reset(pos)
+		reset_meta(pos, fields.code)
+		local err = lc_update(pos, {type="program"})
+		if err then
+			print(err)
+			reset_meta(pos, fields.code, err)
+		end
+	end,
 	sounds = default.node_sound_stone_defaults(),
 	virtual_portstates = {a = false, b = false, c = false, d = false},
-	mesecons = {
-		effector = {
-			rules = mesecon.rules.flat,
-			action_change = function(pos, _, rule_name, new_state)
-				update_real_port_states(pos, rule_name, new_state)
-			end,
-		},
-	},
+	mesecons = mesecons_burnt,
 })
 
 ------------------------

mesecons_materials/init.lua

@@ -14,7 +14,7 @@ minetest.register_craftitem("mesecons_materials:fiber", {
 minetest.register_craft({
 	output = "mesecons_materials:glue 2",
 	type = "cooking",
-	recipe = "group:sapling",
+	recipe = "default:sapling",
 	cooktime = 2
 })
 
@@ -35,7 +35,7 @@ minetest.register_craftitem("mesecons_materials:silicon", {
 minetest.register_craft({
 	output = "mesecons_materials:silicon 4",
 	recipe = {
-		{"group:sand", "group:sand"},
-		{"group:sand", "default:steel_ingot"},
+		{"default:sand", "default:sand"},
+		{"default:sand", "default:steel_ingot"},
 	}
 })

mesecons_microcontroller/init.lua

@@ -1,7 +1,5 @@
 EEPROM_SIZE = 255
 
-local microc_rules = {}
-
 for a = 0, 1 do
 for b = 0, 1 do
 for c = 0, 1 do
@@ -36,7 +34,7 @@ if (a == 0) then table.insert(input_rules, {x = -1, y = 0, z =  0, name = "A"})
 if (b == 0) then table.insert(input_rules, {x =  0, y = 0, z =  1, name = "B"}) end
 if (c == 0) then table.insert(input_rules, {x =  1, y = 0, z =  0, name = "C"}) end
 if (d == 0) then table.insert(input_rules, {x =  0, y = 0, z = -1, name = "D"}) end
-microc_rules[nodename] = rules
+mesecon:add_rules(nodename, rules)
 
 local mesecons = {effector =
 {
@@ -133,8 +131,8 @@ minetest.register_node(nodename, {
 	sounds = default.node_sound_stone_defaults(),
 	mesecons = mesecons,
 	after_dig_node = function (pos, node)
-		rules = microc_rules[node.name]
-		mesecon.receptor_off(pos, rules)
+		rules = mesecon:get_rules(node.name)
+		mesecon:receptor_off(pos, rules)
 	end,
 })
 end
@@ -166,7 +164,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 +183,7 @@ end
 
 --Code Parsing
 function yc_code_remove_commentary(code)
-	local is_string = false
+	is_string = false
 	for i = 1, #code do
 		if code:sub(i, i) == '"' then
 			is_string = not is_string --toggle is_string
@@ -205,17 +203,15 @@ 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
-				local endi_new = yc_skip_to_else (code, endi)
+				endi_new = yc_skip_to_else (code, endi)
 				if endi_new == nil then --else > not found
 					endi = yc_skip_to_endif(code, endi)
 				else
@@ -225,7 +221,7 @@ function yc_parsecode(code, pos)
 			end
 		else
 			params, endi = parse_get_params(code, endi)
-			if not params then return nil end
+			if params  == nil then return nil end
 		end
 		if command == "on" then
 			L = yc_command_on (params, Lvirtual)
@@ -238,7 +234,6 @@ 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
@@ -256,7 +251,7 @@ end
 
 function parse_get_command(code, starti)
 	i = starti
-	local s
+	s = nil
 	while s ~= "" do
 		s = string.sub(code, i, i)
 		if s == "(" then
@@ -282,7 +277,7 @@ end
 
 function parse_get_params(code, starti)
 	i = starti
-	local s
+	s = nil
 	local params = {}
 	local is_string = false
 	while s ~= "" do
@@ -305,7 +300,7 @@ end
 
 function yc_parse_get_eeprom_param(cond, starti)
 	i = starti
-	local s
+	s = nil
 	local addr
 	while s ~= "" do
 		s = string.sub(cond, i, i)
@@ -408,7 +403,7 @@ function yc_command_sbi(params, eeprom, L, Lv)
 	end
 
 	--is an eeprom address
-	local new_eeprom = "";
+	new_eeprom = "";
 	for i=1, #eeprom do
 		if tonumber(params[1])==i then 
 			new_eeprom = new_eeprom..status
@@ -462,17 +457,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 end
-	if not result then end
+	elseif cond == "1" then result = true
+	else result = nil end
+	if result == nil 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
-	local s
+	s = nil
 	local brackets = 1 --1 Bracket to close
 	while s ~= "" do
 		s = string.sub(code, i, i)
@@ -506,8 +501,8 @@ function yc_command_parsecondition(cond, L, eeprom)
 	while i<=l do
 		local s = cond:sub(i,i)
 		if s == "#" then
-			local addr, endi = yc_parse_get_eeprom_param(cond, i+1)
-			local buf = yc_eeprom_read(tonumber(addr), eeprom)
+			addr, endi = yc_parse_get_eeprom_param(cond, i+1)
+			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)
@@ -581,8 +576,10 @@ end
 
 --Virtual-Hardware functions
 function yc_eeprom_read(number, eeprom)
-	if not number then return end
-	return eeprom:sub(number, number)
+	if number == nil then return nil, nil end
+	value = eeprom:sub(number, number)
+	if value  == nil then return nil, nil end
+	return value, endi
 end
 
 --Real I/O functions
@@ -603,24 +600,24 @@ function yc_action_setports(pos, L, Lv)
 	local name = "mesecons_microcontroller:microcontroller"
 	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
+		rules = mesecon:get_rules(name.."0001")
+		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
+		rules = mesecon:get_rules(name.."0010")
+		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
+		rules = mesecon:get_rules(name.."0100")
+		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
+		rules = mesecon:get_rules(name.."1000")
+		if L.d == true then mesecon:receptor_on(pos, rules)
+		else mesecon:receptor_off(pos, rules) end
 	end
 end
 
@@ -640,6 +637,10 @@ 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
@@ -661,6 +662,9 @@ 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)
@@ -669,12 +673,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
-	local name = minetest.get_node(pos).name
-	local b, a = string.find(name, ":microcontroller")
+	name = minetest.get_node(pos).name
+	b, a = string.find(name, ":microcontroller")
 	if a == nil then return nil end
 	a = a + 1
 
-	local Lvirtual = {a=false, b=false, c=false, d=false}
+	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

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,10 +64,10 @@ 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.on_dignode(pos, node)
+			mesecon:update_autoconnect(pos)
 			minetest.add_entity(pos, "mesecons_movestones:movestone_entity")
 		end
 	}}
@@ -89,35 +89,30 @@ 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)
 
-		local maxpush = mesecon.setting("movestone_max_push", 50)
 		if not direction then -- no mesecon power
 			--push only solid nodes
 			local name = minetest.get_node(pos).name
 			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, maxpush)
+				mesecon:mvps_push(pos, self.lastdir, MOVESTONE_MAXIMUM_PUSH)
 			end
-			local nn = {name="mesecons_movestones:movestone"}
-			minetest.add_node(pos, nn)
+			minetest.add_node(pos, {name="mesecons_movestones:movestone"})
 			self.object:remove()
-			mesecon.on_placenode(pos, nn)
 			return
 		end
 
 		local success, stack, oldstack =
-			mesecon.mvps_push(pos, direction, maxpush)
+			mesecon:mvps_push(pos, direction, MOVESTONE_MAXIMUM_PUSH)
 		if not success then -- Too large stack/stopper in the way
-			local nn = {name="mesecons_movestones:movestone"}
-			minetest.add_node(pos, nn)
+			minetest.add_node(pos, {name="mesecons_movestones:movestone"})
 			self.object:remove()
-			mesecon.on_placenode(pos, nn)
 			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
 
@@ -148,10 +143,10 @@ 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.on_dignode(pos, node)
+			mesecon:update_autoconnect(pos)
 			minetest.add_entity(pos, "mesecons_movestones:sticky_movestone_entity")
 		end
 	}}
@@ -180,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
@@ -188,39 +183,34 @@ 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,
-					mesecon.setting("movestone_max_push", 50))
+				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
-			local nn = {name="mesecons_movestones:sticky_movestone"}
-			minetest.add_node(pos, nn)
+			minetest.add_node(pos, {name="mesecons_movestones:sticky_movestone"})
 			self.object:remove()
-			mesecon.on_placenode(pos, nn)
 			return
 		end
 
 		local success, stack, oldstack =
-			mesecon.mvps_push(pos, direction, mesecon.setting("movestone_max_push", 50))
+			mesecon:mvps_push(pos, direction, MOVESTONE_MAXIMUM_PUSH)
 		if not success then -- Too large stack/stopper in the way
-			local nn = {name="mesecons_movestones:sticky_movestone"}
-			minetest.add_node(pos, nn)
+			minetest.add_node(pos, {name="mesecons_movestones:sticky_movestone"})
 			self.object:remove()
-			mesecon.on_placenode(pos, nn)
 			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")

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,16 @@ 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
+		nodeupdate(n.pos)
 		mesecon.on_placenode(n.pos, minetest.get_node(n.pos))
+		mesecon:update_autoconnect(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 +67,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
@@ -90,21 +92,22 @@ function mesecon.mvps_push(pos, dir, maximum) -- pos: pos of mvps; dir: directio
 	-- update mesecons for removed nodes ( has to be done after all nodes have been removed )
 	for _, n in ipairs(nodes) do
 		mesecon.on_dignode(n.pos, n.node)
+		mesecon:update_autoconnect(n.pos)
 	end
 
 	-- add nodes
 	for _, n in ipairs(nodes) do
-		local 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 +118,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)
+		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)
-	local np = mesecon.addPosRule(pos, dir)
-	local nn = minetest.get_node(np)
+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)
@@ -137,13 +140,13 @@ function mesecon.mvps_pull_single(pos, dir) -- pos: pos of mvps; direction: dire
 		nodeupdate(np)
 		nodeupdate(pos)
 		mesecon.on_dignode(np, nn)
-		mesecon.update_autoconnect(np)
+		mesecon:update_autoconnect(np)
 		on_mvps_move({{pos = pos, oldpos = np, node = nn, meta = meta}})
 	end
 	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
@@ -172,7 +175,7 @@ function mesecon.mvps_pull_all(pos, direction) -- pos: pos of mvps; direction: d
 		local meta = minetest.get_meta(lnode2):to_table()
 		minetest.add_node(oldpos, lnode2)
 		minetest.get_meta(oldpos):from_table(meta)
-		moved_nodes[#moved_nodes+1] = {pos = oldpos, oldpos = lpos2, node = lnode2, meta = meta}
+		moved_nodes[#moved_nodes+1] = {pos = oldpos, oldpos = lnode2, node = lnode2, meta = meta}
 		nodeupdate(oldpos)
 		oldpos = {x=lpos2.x, y=lpos2.y, z=lpos2.z}
 		lpos2.x = lpos2.x-direction.x
@@ -185,15 +188,15 @@ function mesecon.mvps_pull_all(pos, direction) -- pos: pos of mvps; direction: d
 	and minetest.registered_nodes[lnode.name].liquidtype ~= "none")
 	minetest.remove_node(oldpos)
 	mesecon.on_dignode(oldpos, lnode2)
-	mesecon.update_autoconnect(oldpos)
+	mesecon:update_autoconnect(oldpos)
 	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 +211,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 +221,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 +234,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")

mesecons_noteblock/init.lua

@@ -2,6 +2,7 @@ minetest.register_node("mesecons_noteblock:noteblock", {
 	description = "Noteblock",
 	tiles = {"mesecons_noteblock.png"},
 	groups = {snappy=2,choppy=2,oddly_breakable_by_hand=2},
+	drawtype = "allfaces_optional",
 	visual_scale = 1.3,
 	paramtype="light",
 	after_place_node = function(pos)
@@ -61,15 +62,9 @@ mesecon.noteblock_play = function (pos, param2)
 	if block_below_name == "default:glass" then
 		soundname="mesecons_noteblock_hihat"
 	end
-	if block_below_name == "default:steelblock" then
-		soundname=soundname.."2" -- Go up an octave.
-	end
 	if block_below_name == "default:stone" then
 		soundname="mesecons_noteblock_kick"
 	end
-	if block_below_name == "default:lava_source" then
-		soundname="fire_large"
-	end
 	if block_below_name == "default:chest" then
 		soundname="mesecons_noteblock_snare"
 	end
@@ -79,9 +74,6 @@ mesecon.noteblock_play = function (pos, param2)
 	if block_below_name == "default:wood" then
 		soundname="mesecons_noteblock_litecrash"
 	end
-	if block_below_name == "default:coalblock" then
-		soundname="tnt_explode"
-	end
 	minetest.sound_play(soundname,
 	{pos = pos, gain = 1.0, max_hear_distance = 32,})
 end

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
@@ -55,16 +55,15 @@ piston_get_direction = function(dir, node)
 end
 
 local piston_remove_pusher = function(pos, node)
-	local pistonspec = minetest.registered_nodes[node.name].mesecons_piston
-	local dir = piston_get_direction(pistonspec.dir, node)
-	local pusherpos = mesecon.addPosRule(pos, dir)
-	local pushername = minetest.get_node(pusherpos).name
-
-	-- make sure there actually is a pusher (for compatibility reasons mainly)
-	if pushername ~= pistonspec.pusher then
+	pistonspec = minetest.registered_nodes[node.name].mesecons_piston
+	if pushername == pistonspec.pusher then --make sure there actually is a pusher (for compatibility reasons mainly)
 		return
 	end
 
+	dir = piston_get_direction(pistonspec.dir, node)
+	local pusherpos = mesecon:addPosRule(pos, dir)
+	local pushername = minetest.get_node(pusherpos).name
+
 	minetest.remove_node(pusherpos)
 	minetest.sound_play("piston_retract", {
 		pos = pos,
@@ -78,9 +77,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 maxpush = mesecon.setting("piston_max_push", 15)
-	local success, stack, oldstack = mesecon.mvps_push(np, dir, maxpush)
+	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})
@@ -89,8 +87,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,10 +98,10 @@ local piston_off = function(pos, node)
 	piston_remove_pusher(pos, node)
 
 	if pistonspec.sticky then
-		local dir = piston_get_direction(pistonspec.dir, node)
-		local pullpos = mesecon.addPosRule(pos, dir)
-		local stack = mesecon.mvps_pull_single(pullpos, dir)
-		mesecon.mvps_process_stack(pos, dir, stack)
+		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)
 	end
 end
 
@@ -694,14 +692,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
@@ -718,12 +716,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
@@ -732,14 +730,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({

mesecons_powerplant/init.lua

@@ -26,6 +26,6 @@ minetest.register_craft({
 	recipe = {
 		{"group:mesecon_conductor_craftable"},
 		{"group:mesecon_conductor_craftable"},
-		{"group:sapling"},
+		{"default:sapling"},
 	}
 })

mesecons_pressureplates/init.lua

@@ -9,25 +9,31 @@ local pp_box_on = {
 }
 
 pp_on_timer = function (pos, elapsed)
-	local node = minetest.get_node(pos)
-	local basename = minetest.registered_nodes[node.name].pressureplate_basename
+	local node   = minetest.get_node(pos)
+	local ppspec = minetest.registered_nodes[node.name].pressureplate
 
 	-- This is a workaround for a strange bug that occurs when the server is started
 	-- For some reason the first time on_timer is called, the pos is wrong
-	if not basename then return end
+	if not ppspec 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)
+	if objs[1] == nil and node.name == ppspec.onstate then
+		minetest.add_node(pos, {name = ppspec.offstate})
+		mesecon:receptor_off(pos)
+		-- force deactivation of mesecon two blocks below (hacky)
+		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 )
+				minetest.add_node(pos, {name=ppspec.onstate})
+				mesecon:receptor_on(pos)
+				-- force activation of mesecon two blocks below (hacky)
+				mesecon:turnon(two_below)
 			end
 		end
 	end
@@ -43,40 +49,66 @@ 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)
-	mesecon.register_node(basename, {
+function mesecon:register_pressure_plate(offstate, onstate, description, textures_off, textures_on, image_w, image_i, recipe)
+	local ppspec = {
+		offstate = offstate,
+		onstate  = onstate
+	}
+
+	minetest.register_node(offstate, {
 		drawtype = "nodebox",
+		tiles = textures_off,
 		inventory_image = image_i,
 		wield_image = image_w,
 		paramtype = "light",
-	    	description = description,
-		pressureplate_basename = basename,
-		on_timer = pp_on_timer,
-		on_construct = function(pos)
-			minetest.get_node_timer(pos):start(mesecon.setting("pplate_interval", 0.1))
-		end,
-	},{
-		mesecons = {receptor = { state = mesecon.state.off, rules = mesecon.rules.pplate }},
-		node_box = pp_box_off,
 		selection_box = pp_box_off,
+		node_box = pp_box_off,
 		groups = {snappy = 2, oddly_breakable_by_hand = 3},
-		tiles = textures_off
-	},{
-		mesecons = {receptor = { state = mesecon.state.on, rules = mesecon.rules.pplate }},
-		node_box = pp_box_on,
+	    	description = description,
+		pressureplate = ppspec,
+		on_timer = pp_on_timer,
+		mesecons = {receptor = {
+			state = mesecon.state.off
+		}},
+		on_construct = function(pos)
+			minetest.get_node_timer(pos):start(PRESSURE_PLATE_INTERVAL)
+		end,
+	})
+
+	minetest.register_node(onstate, {
+		drawtype = "nodebox",
+		tiles = textures_on,
+		paramtype = "light",
 		selection_box = pp_box_on,
+		node_box = pp_box_on,
 		groups = {snappy = 2, oddly_breakable_by_hand = 3, not_in_creative_inventory = 1},
-		tiles = textures_on
+		drop = offstate,
+		pressureplate = ppspec,
+		on_timer = pp_on_timer,
+		sounds = default.node_sound_wood_defaults(),
+		mesecons = {receptor = {
+			state = mesecon.state.on
+		}},
+		on_construct = function(pos)
+			minetest.get_node_timer(pos):start(PRESSURE_PLATE_INTERVAL)
+		end,
+		after_dig_node = function(pos)
+			local two_below = mesecon:addPosRule(pos, {x = 0, y = -2, z = 0})
+			if not mesecon:connected_to_receptor(two_below) then
+				mesecon:turnoff(two_below)
+			end
+		end
 	})
 
 	minetest.register_craft({
-		output = basename .. "_off",
+		output = offstate,
 		recipe = recipe,
 	})
 end
 
-mesecon.register_pressure_plate(
-	"mesecons_pressureplates:pressure_plate_wood",
+mesecon:register_pressure_plate(
+	"mesecons_pressureplates:pressure_plate_wood_off",
+	"mesecons_pressureplates:pressure_plate_wood_on",
 	"Wooden Pressure Plate",
 	{"jeija_pressure_plate_wood_off.png","jeija_pressure_plate_wood_off.png","jeija_pressure_plate_wood_off_edges.png"},
 	{"jeija_pressure_plate_wood_on.png","jeija_pressure_plate_wood_on.png","jeija_pressure_plate_wood_on_edges.png"},
@@ -84,8 +116,9 @@ mesecon.register_pressure_plate(
 	"jeija_pressure_plate_wood_inv.png",
 	{{"group:wood", "group:wood"}})
 
-mesecon.register_pressure_plate(
-	"mesecons_pressureplates:pressure_plate_stone",
+mesecon:register_pressure_plate(
+	"mesecons_pressureplates:pressure_plate_stone_off",
+	"mesecons_pressureplates:pressure_plate_stone_on",
 	"Stone Pressure Plate",
 	{"jeija_pressure_plate_stone_off.png","jeija_pressure_plate_stone_off.png","jeija_pressure_plate_stone_off_edges.png"},
 	{"jeija_pressure_plate_stone_on.png","jeija_pressure_plate_stone_on.png","jeija_pressure_plate_stone_on_edges.png"},

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

mesecons_receiver/init.lua

@@ -1,19 +1,19 @@
 rcvboxes = {
-	{ -3/16, -3/16, -8/16       , 3/16,  3/16  , -13/32       }, -- the smaller bump	
-	{ -1/32, -1/32, -3/2        , 1/32,  1/32  , -1/2         }, -- the wire through the block
-	{ -2/32, -1/2 , -.5         , 2/32,  0     , -.5002+3/32  }, -- the vertical wire bit
-	{ -2/32, -1/2 , -7/16+0.002 , 2/32,  -14/32,  16/32+0.001 }  -- the horizontal wire
+	{ -3/16, -3/16   , -8/16       , 3/16,     3/16, -13/32       }, -- the smaller bump	
+	{ -1/32, -1/32   , -3/2        , 1/32,     1/32, -1/2         }, -- the wire through the block
+	{ -2/32, -.5-1/32, -.5         , 2/32,    0    , -.5002+3/32  }, -- the vertical wire bit
+	{ -2/32, -17/32  , -7/16+0.002 , 2/32,   -14/32,  16/32+0.001 }  -- the horizontal wire
 }
 
 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,76 +81,83 @@ minetest.register_node("mesecons_receiver:receiver_off", {
 	}}
 })
 
-function mesecon.receiver_get_pos_from_rcpt(pos, param2)
-	local rules = {{x = 2,  y = 0, z = 0}}
+mesecon:add_rules("receiver_pos", {{x = 2,  y = 0, z = 0}})
+
+mesecon:add_rules("receiver_pos_all", {
+{x = 2,  y = 0, z = 0},
+{x =-2,  y = 0, z = 0},
+{x = 0,  y = 0, z = 2},
+{x = 0,  y = 0, z =-2}})
+
+function mesecon:receiver_get_pos_from_rcpt(pos, param2)
+	local rules = mesecon:get_rules("receiver_pos")
 	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
-	local np = {	x = pos.x + rules[1].x,
-			y = pos.y + rules[1].y,
-			z = pos.z + rules[1].z}
+	np = {
+	x = pos.x + rules[1].x,
+	y = pos.y + rules[1].y,
+	z = pos.z + rules[1].z}
 	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
-		mesecon.update_autoconnect(pos)
+		mesecon:update_autoconnect(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)
 		local node = {name = "mesecons:wire_00000000_off"}
 		minetest.add_node(pos, node)
-		mesecon.update_autoconnect(pos)
+		mesecon:update_autoconnect(pos)
 		mesecon.on_placenode(pos, node)
 	end
 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)
 
 minetest.register_on_placenode(function (pos, node)
 	if string.find(node.name, "mesecons:wire_") ~=nil then
-		local rules = {	{x = 2,  y = 0, z = 0},
-				{x =-2,  y = 0, z = 0},
-				{x = 0,  y = 0, z = 2},
-				{x = 0,  y = 0, z =-2}}
+		rules = mesecon:get_rules("receiver_pos_all")
 		local i = 1
 		while rules[i] ~= nil do
-			local np = {	x = pos.x + rules[i].x,
-					y = pos.y + rules[i].y,
-					z = pos.z + rules[i].z}
+			np = {
+			x = pos.x + rules[i].x,
+			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

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

mesecons_switch/init.lua

@@ -1,29 +1,35 @@
 -- MESECON_SWITCH
 
-mesecon.register_node("mesecons_switch:mesecon_switch", {
+minetest.register_node("mesecons_switch:mesecon_switch_off", {
+	tiles = {"jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_off.png"},
 	paramtype2="facedir",
+	groups = {dig_immediate=2},
 	description="Switch",
 	sounds = default.node_sound_stone_defaults(),
-	on_punch = function (pos, node)
-		if(mesecon.flipstate(pos, node) == "on") then
-			mesecon.receptor_on(pos)
-		else
-			mesecon.receptor_off(pos)
-		end
+	mesecons = {receptor = {
+		state = mesecon.state.off
+	}},
+	on_punch = function(pos, node)
+		minetest.swap_node(pos, {name = "mesecons_switch:mesecon_switch_on", param2 = node.param2})
+		mesecon:receptor_on(pos)
+		minetest.sound_play("mesecons_switch", {pos=pos})
+	end
+})
+
+minetest.register_node("mesecons_switch:mesecon_switch_on", {
+	tiles = {"jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_on.png"},
+	paramtype2="facedir",
+	groups = {dig_immediate=2,not_in_creative_inventory=1},
+	drop="mesecons_switch:mesecon_switch_off 1",
+	sounds = default.node_sound_stone_defaults(),
+	mesecons = {receptor = {
+		state = mesecon.state.on
+	}},
+	on_punch = function(pos, node)
+		minetest.swap_node(pos, {name = "mesecons_switch:mesecon_switch_off", param2 = node.param2})
+		mesecon:receptor_off(pos)
 		minetest.sound_play("mesecons_switch", {pos=pos})
 	end
-},{
-	groups = {dig_immediate=2},
-	tiles = {	"jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png",
-			"jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png",
-			"jeija_mesecon_switch_side.png", "jeija_mesecon_switch_off.png"},
-	mesecons = {receptor = { state = mesecon.state.off }}
-},{
-	groups = {dig_immediate=2, not_in_creative_inventory=1},
-	tiles = {	"jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png",
-			"jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png",
-			"jeija_mesecon_switch_side.png", "jeija_mesecon_switch_on.png"},
-	mesecons = {receptor = { state = mesecon.state.on }}
 })
 
 minetest.register_craft({

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

mesecons_walllever/init.lua

@@ -1,11 +1,18 @@
 -- WALL LEVER
 -- Basically a switch that can be attached to a wall
 -- Powers the block 2 nodes behind (using a receiver)
-mesecon.register_node("mesecons_walllever:wall_lever", {
-	description="Lever",
-	drawtype = "mesh",
-	inventory_image = "jeija_wall_lever_inv.png",
-	wield_image = "jeija_wall_lever_inv.png",
+minetest.register_node("mesecons_walllever:wall_lever_off", {
+	drawtype = "nodebox",
+	tiles = {
+		"jeija_wall_lever_tb.png",
+		"jeija_wall_lever_bottom.png",
+		"jeija_wall_lever_sides.png",
+		"jeija_wall_lever_sides.png",
+		"jeija_wall_lever_back.png",
+		"jeija_wall_lever_off.png",
+	},
+	inventory_image = "jeija_wall_lever_off.png",
+	wield_image = "jeija_wall_lever_off.png",
 	paramtype = "light",
 	paramtype2 = "facedir",
 	sunlight_propagates = true,
@@ -14,31 +21,68 @@ mesecon.register_node("mesecons_walllever:wall_lever", {
 		type = "fixed",
 		fixed = { -8/16, -8/16, 3/16, 8/16, 8/16, 8/16 },
 	},
-	sounds = default.node_sound_wood_defaults(),
+	node_box = {
+		type = "fixed",
+		fixed = {{ -6/16, -6/16, 6/16, 6/16,  6/16, 8/16 },	-- the base "slab"
+			 { -5/16, -3/16, 5/16, 5/16,  3/16, 6/16 },	-- the lighted ring area
+			 { -4/16, -2/16, 4/16, 4/16,  2/16, 5/16 },	-- the raised bit that the lever "sits" on
+			 { -2/16, -1/16, 3/16, 2/16,  1/16, 4/16 },	-- the lever "hinge"
+			 { -1/16, -8/16, 4/16, 1/16,  0,    6/16 }}	-- the lever itself.
+	},
+	groups = {dig_immediate=2, mesecon_needs_receiver = 1},
+	description="Lever",
 	on_punch = function (pos, node)
-		if(mesecon.flipstate(pos, node) == "on") then
-			mesecon.receptor_on(pos, mesecon.rules.buttonlike_get(node))
-		else
-			mesecon.receptor_off(pos, mesecon.rules.buttonlike_get(node))
-		end
+		minetest.swap_node(pos, {name = "mesecons_walllever:wall_lever_on", param2 = node.param2})
+		mesecon:receptor_on(pos, mesecon.rules.buttonlike_get(node))
 		minetest.sound_play("mesecons_lever", {pos=pos})
-	end
-},{
-	tiles = { "jeija_wall_lever_off.png" },
-	mesh="jeija_wall_lever_off.obj",
+	end,
+	sounds = default.node_sound_wood_defaults(),
 	mesecons = {receptor = {
 		rules = mesecon.rules.buttonlike_get,
 		state = mesecon.state.off
-	}},
-	groups = {dig_immediate = 2, mesecon_needs_receiver = 1}
-},{
-	tiles = { "jeija_wall_lever_on.png" },
-	mesh="jeija_wall_lever_on.obj",
+	}}
+})
+minetest.register_node("mesecons_walllever:wall_lever_on", {
+	drawtype = "nodebox",
+	tiles = {
+		"jeija_wall_lever_top.png",
+		"jeija_wall_lever_tb.png",
+		"jeija_wall_lever_sides.png",
+		"jeija_wall_lever_sides.png",
+		"jeija_wall_lever_back.png",
+		"jeija_wall_lever_on.png",
+	},
+	inventory_image = "jeija_wall_lever_on.png",
+	paramtype = "light",
+	paramtype2 = "facedir",
+	sunlight_propagates = true,
+	walkable = false,
+	light_source = LIGHT_MAX-7,
+	selection_box = {
+		type = "fixed",
+		fixed = { -8/16, -8/16, 3/16, 8/16, 8/16, 8/16 },
+	},
+	node_box = {
+		type = "fixed",
+		fixed = {{ -6/16, -6/16,  6/16, 6/16, 6/16,  8/16 },	-- the base "slab"
+			 { -5/16, -3/16,  5/16, 5/16, 3/16,  6/16 },	-- the lighted ring area
+			 { -4/16, -2/16,  4/16, 4/16, 2/16,  5/16 },	-- the raised bit that the lever "sits" on
+			 { -2/16, -1/16,  3/16, 2/16, 1/16,  4/16 },	-- the lever "hinge"
+			 { -1/16,  0,     4/16, 1/16, 8/16,  6/16 }}	-- the lever itself.
+	},
+	groups = {dig_immediate = 2, not_in_creative_inventory = 1, mesecon_needs_receiver = 1},
+	drop = "mesecons_walllever:wall_lever_off 1",
+	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))
+		minetest.sound_play("mesecons_lever", {pos=pos})
+	end,
+	sounds = default.node_sound_wood_defaults(),
 	mesecons = {receptor = {
 		rules = mesecon.rules.buttonlike_get,
 		state = mesecon.state.on
-	}},
-	groups = {dig_immediate = 2, mesecon_needs_receiver = 1, not_in_creative_inventory = 1}
+	}}
 })
 
 minetest.register_craft({

mesecons_walllever/models/jeija_wall_lever_off.obj

@@ -1,263 +0,0 @@
-# Blender v2.73 (sub 0) OBJ File: 'mesecons-wall-lever-off.blend'
-# www.blender.org
-o nodebox-5
-v 0.289062 0.156250 0.312500
-v -0.375000 0.375000 0.375000
-v -0.375000 -0.375000 0.375000
-v 0.332500 0.207500 0.375000
-v 0.332500 -0.207500 0.375000
-v 0.375000 0.375000 0.375000
-v 0.375000 -0.375000 0.375000
-v 0.289062 -0.156250 0.312500
-v -0.062500 -0.036146 0.200392
-v -0.062500 -0.068498 0.321133
-v -0.062500 -0.394498 0.233782
-v -0.062500 -0.362146 0.113041
-v -0.332500 0.207500 0.375000
-v 0.062500 -0.036146 0.200392
-v 0.062500 -0.068498 0.321133
-v -0.332500 -0.207500 0.375000
-v 0.332500 0.207500 0.375000
-v 0.062500 -0.394498 0.233782
-v 0.062500 -0.362146 0.113041
-v 0.332500 -0.207500 0.375000
-v 0.375000 -0.375000 0.375000
-v 0.375000 -0.375000 0.500000
-v 0.375000 0.375000 0.500000
-v 0.375000 0.375000 0.375000
-v -0.375000 -0.375000 0.375000
-v -0.375000 -0.375000 0.500000
-v -0.375000 0.375000 0.500000
-v -0.375000 0.375000 0.375000
-v -0.289062 0.156250 0.312500
-v -0.332500 0.207500 0.375000
-v -0.332500 -0.207500 0.375000
-v -0.289062 -0.156250 0.312500
-v -0.250000 0.125000 0.312500
-v -0.250000 -0.125000 0.312500
-v 0.250000 0.125000 0.312500
-v 0.250000 -0.125000 0.312500
-v -0.250000 -0.000000 0.250000
-v -0.000000 -0.125000 0.250000
-v 0.250000 -0.000000 0.250000
-v 0.000000 0.125000 0.250000
-v -0.250000 0.125000 0.250000
-v -0.250000 0.125000 0.312500
-v -0.250000 -0.125000 0.312500
-v -0.250000 -0.125000 0.250000
-v 0.250000 0.125000 0.250000
-v 0.250000 0.125000 0.312500
-v 0.250000 -0.125000 0.312500
-v 0.250000 -0.125000 0.250000
-v 0.250000 -0.125000 0.250000
-v 0.250000 0.125000 0.250000
-v -0.250000 -0.125000 0.250000
-v -0.250000 0.125000 0.250000
-v 0.125000 -0.062500 0.187500
-v 0.125000 0.062500 0.187500
-v -0.125000 -0.062500 0.187500
-v -0.125000 0.062500 0.187500
-v 0.065000 -0.032500 0.176992
-v 0.065000 0.032500 0.176992
-v -0.065000 -0.032500 0.176992
-v -0.065000 0.032500 0.176992
-v 0.000000 0.125000 0.250000
-v 0.250000 -0.000000 0.250000
-v -0.000000 -0.125000 0.250000
-v -0.250000 -0.000000 0.250000
-v 0.000000 0.062500 0.187500
-v -0.187500 -0.093750 0.208750
-v 0.125000 -0.000000 0.187500
-v 0.000000 -0.062500 0.187500
-v -0.125000 -0.000000 0.187500
-v 0.187500 0.093750 0.208750
-v 0.187500 -0.093750 0.208750
-v -0.187500 0.093750 0.208750
-v 0.000000 0.093750 0.208750
-v 0.000000 -0.093750 0.208750
-v 0.187500 -0.000000 0.208750
-v -0.187500 -0.000000 0.208750
-vt 0.416667 0.416667
-vt 0.083333 0.416667
-vt 0.055556 0.472222
-vt 0.444444 0.472222
-vt 0.083333 0.083333
-vt 0.055556 0.027778
-vt 0.444444 0.027778
-vt 0.416667 0.083333
-vt 0.472222 0.055556
-vt 0.472222 0.444444
-vt 0.027778 0.055556
-vt 0.027778 0.444444
-vt 0.250000 0.833333
-vt 0.250000 0.638889
-vt 0.305556 0.638889
-vt 0.305556 0.833333
-vt 0.388889 0.777778
-vt 0.333333 0.777778
-vt 0.333333 0.722222
-vt 0.388889 0.722222
-vt 0.944444 0.527778
-vt 0.944444 0.916667
-vt 1.000000 0.916667
-vt 1.000000 0.527778
-vt 0.500000 0.527778
-vt 0.555556 0.527778
-vt 0.555556 0.916667
-vt 0.500000 0.916667
-vt 0.138889 0.833333
-vt 0.194444 0.833333
-vt 0.194444 0.638889
-vt 0.138889 0.638889
-vt 0.944444 0.472222
-vt 0.555556 0.472222
-vt 0.555556 0.972222
-vt 0.944444 0.972222
-vt 0.888802 0.166753
-vt 0.555642 0.166753
-vt 0.527778 0.138889
-vt 0.916667 0.138889
-vt 0.888802 0.388802
-vt 0.916667 0.416667
-vt 0.527778 0.416667
-vt 0.555642 0.388802
-vt 0.361111 0.361111
-vt 0.250000 0.361111
-vt 0.138889 0.361111
-vt 0.138889 0.416667
-vt 0.361111 0.416667
-vt 0.361111 0.083333
-vt 0.361111 0.138889
-vt 0.138889 0.138889
-vt 0.138889 0.083333
-vt 0.250000 0.083333
-vt 0.416667 0.361111
-vt 0.416667 0.138889
-vt 0.416667 0.250000
-vt 0.138889 0.250000
-vt 0.083333 0.138889
-vt 0.083333 0.361111
-vt 0.083333 0.638889
-vt 0.083333 0.833333
-vt 0.444444 0.611111
-vt 0.055556 0.611111
-vt 0.027778 0.527778
-vt 0.472222 0.527778
-vt 0.444444 0.888889
-vt 0.472222 0.972222
-vt 0.055556 0.888889
-vt 0.027778 0.972222
-vt 0.722222 0.361111
-vt 0.583333 0.361111
-vt 0.722222 0.388802
-vt 0.833333 0.333333
-vt 0.777778 0.305556
-vt 0.777778 0.250000
-vt 0.833333 0.222222
-vt 0.833333 0.277778
-vt 0.722222 0.194444
-vt 0.722222 0.166753
-vt 0.861111 0.194444
-vt 0.583333 0.277778
-vt 0.583333 0.194444
-vt 0.555642 0.277778
-vt 0.861111 0.277778
-vt 0.888802 0.277778
-vt 0.861111 0.361111
-vt 0.666667 0.250000
-vt 0.666667 0.305556
-vt 0.611111 0.222222
-vt 0.722222 0.222222
-vt 0.611111 0.333333
-vt 0.611111 0.277778
-vt 0.722222 0.333333
-vn 0.000000 0.773300 -0.634100
-vn 0.000000 -0.773300 -0.634100
-vn -0.821200 0.000000 -0.570700
-vn 0.821200 0.000000 -0.570700
-vn 0.000000 -0.258800 0.965900
-vn 0.000000 -0.965900 -0.258800
-vn 1.000000 0.000000 0.000000
-vn -1.000000 0.000000 0.000000
-vn 0.000000 0.258800 -0.965900
-vn 0.000000 -0.000000 1.000000
-vn 0.000000 -1.000000 0.000000
-vn 0.000000 1.000000 0.000000
-vn 0.000000 0.000000 -1.000000
-vn 0.000000 0.688800 -0.724900
-vn -0.269900 0.421500 -0.865700
-vn -0.395600 0.336800 -0.854500
-vn 0.000000 0.797100 -0.603900
-vn -0.142400 0.274900 -0.950900
-vn -0.056900 0.142700 -0.988100
-vn -0.056900 -0.142700 -0.988100
-vn -0.142400 -0.274900 -0.950900
-vn -0.247900 0.000000 -0.968700
-vn 0.000000 -0.688800 -0.724900
-vn 0.000000 -0.797100 -0.603900
-vn -0.395600 -0.336800 -0.854500
-vn -0.269900 -0.421500 -0.865700
-vn 0.440000 0.000000 -0.898000
-vn 0.269900 0.421500 -0.865700
-vn 0.395600 0.336800 -0.854500
-vn 0.550800 0.000000 -0.834600
-vn -0.440000 0.000000 -0.898000
-vn -0.550800 0.000000 -0.834600
-vn 0.056900 -0.142700 -0.988100
-vn 0.056900 0.142700 -0.988100
-vn 0.142400 -0.274900 -0.950900
-vn 0.000000 -0.450200 -0.892900
-vn 0.142400 0.274900 -0.950900
-vn 0.247900 0.000000 -0.968700
-vn 0.000000 0.450200 -0.892900
-vn 0.269900 -0.421500 -0.865700
-vn 0.395600 -0.336800 -0.854500
-s off
-f 1/1/1 29/2/1 30/3/1 4/4/1
-f 8/5/2 5/6/2 31/7/2 32/8/2
-f 32/8/3 31/9/3 30/10/3 29/1/3
-f 8/2/4 1/5/4 4/11/4 5/12/4
-f 18/13/5 15/14/5 10/15/5 11/16/5
-f 19/17/6 18/18/6 11/19/6 12/20/6
-f 21/21/7 24/22/7 23/23/7 22/24/7
-f 25/25/8 26/26/8 27/27/8 28/28/8
-f 19/29/9 12/30/9 9/31/9 14/32/9
-f 22/26/10 23/21/10 27/22/10 26/27/10
-f 21/33/11 22/21/11 26/26/11 25/34/11
-f 24/22/12 28/27/12 27/35/12 23/36/12
-f 34/37/13 36/38/13 8/39/13 32/40/13
-f 33/41/13 34/37/13 32/40/13 29/42/13
-f 33/41/13 29/42/13 1/43/13 35/44/13
-f 35/44/13 1/43/13 8/39/13 36/38/13
-f 45/45/12 40/46/12 41/47/12 42/48/12 46/49/12
-f 48/50/11 47/51/11 43/52/11 44/53/11 38/54/11
-f 44/55/8 43/45/8 42/51/8 41/56/8 37/57/8
-f 48/47/7 39/58/7 45/52/7 46/59/7 47/60/7
-f 12/13/8 11/30/8 10/31/8 9/14/8
-f 19/29/7 14/32/7 15/61/7 18/62/7
-f 16/63/13 20/64/13 7/65/13 3/66/13
-f 13/67/13 16/63/13 3/66/13 2/68/13
-f 17/69/13 6/70/13 7/65/13 20/64/13
-f 13/67/13 2/68/13 6/70/13 17/69/13
-s 1
-f 73/71/14 72/72/15 52/44/16 61/73/17
-f 56/74/18 60/75/19 59/76/20 55/77/21 69/78/22
-f 74/79/23 63/80/24 51/37/25 66/81/26
-f 75/82/27 70/83/28 50/38/29 62/84/30
-f 76/85/31 64/86/32 52/41/16 72/87/15
-f 57/88/33 59/76/20 60/75/19 58/89/34
-f 55/77/21 59/76/20 57/88/33 53/90/35 68/91/36
-f 53/90/35 57/88/33 58/89/34 54/92/37 67/93/38
-f 54/92/37 58/89/34 60/75/19 56/74/18 65/94/39
-f 65/94/39 56/92/18 72/72/15 73/71/14
-f 54/74/37 65/94/39 73/71/14 70/87/28
-f 70/87/28 73/71/14 61/73/17 50/41/29
-f 68/91/36 74/79/23 66/81/26 55/77/21
-f 53/90/35 71/83/40 74/79/23 68/91/36
-f 71/83/40 49/38/41 63/80/24 74/79/23
-f 67/93/38 54/90/37 70/83/28 75/82/27
-f 53/92/35 67/93/38 75/82/27 71/72/40
-f 71/72/40 75/82/27 62/84/30 49/44/41
-f 69/78/22 76/85/31 72/87/15 56/74/18
-f 55/77/21 66/81/26 76/85/31 69/78/22
-f 66/81/26 51/37/25 64/86/32 76/85/31

mesecons_walllever/models/jeija_wall_lever_on.obj

@@ -1,263 +0,0 @@
-# Blender v2.73 (sub 0) OBJ File: 'mesecons-wall-lever.blend'
-# www.blender.org
-o nodebox-5
-v 0.289062 0.156250 0.312500
-v -0.375000 0.375000 0.375000
-v -0.375000 -0.375000 0.375000
-v 0.332500 0.207500 0.375000
-v 0.332500 -0.207500 0.375000
-v 0.375000 0.375000 0.375000
-v 0.375000 -0.375000 0.375000
-v 0.289062 -0.156250 0.312500
-v -0.062500 0.075354 0.315617
-v -0.062500 0.043002 0.194876
-v -0.062500 0.369002 0.107525
-v -0.062500 0.401354 0.228266
-v -0.332500 0.207500 0.375000
-v 0.062500 0.075354 0.315617
-v 0.062500 0.043002 0.194876
-v -0.332500 -0.207500 0.375000
-v 0.332500 0.207500 0.375000
-v 0.062500 0.369002 0.107525
-v 0.062500 0.401354 0.228266
-v 0.332500 -0.207500 0.375000
-v 0.375000 -0.375000 0.375000
-v 0.375000 -0.375000 0.500000
-v 0.375000 0.375000 0.500000
-v 0.375000 0.375000 0.375000
-v -0.375000 -0.375000 0.375000
-v -0.375000 -0.375000 0.500000
-v -0.375000 0.375000 0.500000
-v -0.375000 0.375000 0.375000
-v -0.289062 0.156250 0.312500
-v -0.332500 0.207500 0.375000
-v -0.332500 -0.207500 0.375000
-v -0.289062 -0.156250 0.312500
-v -0.250000 0.125000 0.312500
-v -0.250000 -0.125000 0.312500
-v 0.250000 0.125000 0.312500
-v 0.250000 -0.125000 0.312500
-v -0.250000 -0.000000 0.250000
-v -0.000000 -0.125000 0.250000
-v 0.250000 -0.000000 0.250000
-v 0.000000 0.125000 0.250000
-v -0.250000 0.125000 0.250000
-v -0.250000 0.125000 0.312500
-v -0.250000 -0.125000 0.312500
-v -0.250000 -0.125000 0.250000
-v 0.250000 0.125000 0.250000
-v 0.250000 0.125000 0.312500
-v 0.250000 -0.125000 0.312500
-v 0.250000 -0.125000 0.250000
-v 0.250000 -0.125000 0.250000
-v 0.250000 0.125000 0.250000
-v -0.250000 -0.125000 0.250000
-v -0.250000 0.125000 0.250000
-v 0.125000 -0.062500 0.187500
-v 0.125000 0.062500 0.187500
-v -0.125000 -0.062500 0.187500
-v -0.125000 0.062500 0.187500
-v 0.065000 -0.032500 0.176992
-v 0.065000 0.032500 0.176992
-v -0.065000 -0.032500 0.176992
-v -0.065000 0.032500 0.176992
-v 0.000000 0.125000 0.250000
-v 0.250000 -0.000000 0.250000
-v -0.000000 -0.125000 0.250000
-v -0.250000 -0.000000 0.250000
-v 0.000000 0.062500 0.187500
-v -0.187500 -0.093750 0.208750
-v 0.125000 -0.000000 0.187500
-v 0.000000 -0.062500 0.187500
-v -0.125000 -0.000000 0.187500
-v 0.187500 0.093750 0.208750
-v 0.187500 -0.093750 0.208750
-v -0.187500 0.093750 0.208750
-v 0.000000 0.093750 0.208750
-v 0.000000 -0.093750 0.208750
-v 0.187500 -0.000000 0.208750
-v -0.187500 -0.000000 0.208750
-vt 0.416667 0.416667
-vt 0.083333 0.416667
-vt 0.055556 0.472222
-vt 0.444444 0.472222
-vt 0.083333 0.083333
-vt 0.055556 0.027778
-vt 0.444444 0.027778
-vt 0.416667 0.083333
-vt 0.472222 0.055556
-vt 0.472222 0.444444
-vt 0.027778 0.055556
-vt 0.027778 0.444444
-vt 0.250000 0.833333
-vt 0.250000 0.638889
-vt 0.305556 0.638889
-vt 0.305556 0.833333
-vt 0.388889 0.777778
-vt 0.333333 0.777778
-vt 0.333333 0.722222
-vt 0.388889 0.722222
-vt 0.944444 0.527778
-vt 0.944444 0.916667
-vt 1.000000 0.916667
-vt 1.000000 0.527778
-vt 0.500000 0.527778
-vt 0.555556 0.527778
-vt 0.555556 0.916667
-vt 0.500000 0.916667
-vt 0.138889 0.833333
-vt 0.194444 0.833333
-vt 0.194444 0.638889
-vt 0.138889 0.638889
-vt 0.944444 0.472222
-vt 0.555556 0.472222
-vt 0.555556 0.972222
-vt 0.944444 0.972222
-vt 0.888802 0.166753
-vt 0.555642 0.166753
-vt 0.527778 0.138889
-vt 0.916667 0.138889
-vt 0.888802 0.388802
-vt 0.916667 0.416667
-vt 0.527778 0.416667
-vt 0.555642 0.388802
-vt 0.361111 0.361111
-vt 0.250000 0.361111
-vt 0.138889 0.361111
-vt 0.138889 0.416667
-vt 0.361111 0.416667
-vt 0.361111 0.083333
-vt 0.361111 0.138889
-vt 0.138889 0.138889
-vt 0.138889 0.083333
-vt 0.250000 0.083333
-vt 0.416667 0.361111
-vt 0.416667 0.138889
-vt 0.416667 0.250000
-vt 0.138889 0.250000
-vt 0.083333 0.138889
-vt 0.083333 0.361111
-vt 0.083333 0.638889
-vt 0.083333 0.833333
-vt 0.444444 0.611111
-vt 0.055556 0.611111
-vt 0.027778 0.527778
-vt 0.472222 0.527778
-vt 0.444444 0.888889
-vt 0.472222 0.972222
-vt 0.055556 0.888889
-vt 0.027778 0.972222
-vt 0.722222 0.361111
-vt 0.583333 0.361111
-vt 0.722222 0.388802
-vt 0.833333 0.333333
-vt 0.777778 0.305556
-vt 0.777778 0.250000
-vt 0.833333 0.222222
-vt 0.833333 0.277778
-vt 0.722222 0.194444
-vt 0.722222 0.166753
-vt 0.861111 0.194444
-vt 0.583333 0.277778
-vt 0.583333 0.194444
-vt 0.555642 0.277778
-vt 0.861111 0.277778
-vt 0.888802 0.277778
-vt 0.861111 0.361111
-vt 0.666667 0.250000
-vt 0.666667 0.305556
-vt 0.611111 0.222222
-vt 0.722222 0.222222
-vt 0.611111 0.333333
-vt 0.611111 0.277778
-vt 0.722222 0.333333
-vn 0.000000 0.773300 -0.634100
-vn 0.000000 -0.773300 -0.634100
-vn -0.821200 0.000000 -0.570700
-vn 0.821200 0.000000 -0.570700
-vn 0.000000 -0.258800 -0.965900
-vn 0.000000 0.965900 -0.258800
-vn 1.000000 0.000000 0.000000
-vn -1.000000 0.000000 0.000000
-vn 0.000000 0.258800 0.965900
-vn 0.000000 -0.000000 1.000000
-vn 0.000000 -1.000000 0.000000
-vn 0.000000 1.000000 0.000000
-vn 0.000000 0.000000 -1.000000
-vn 0.000000 0.688800 -0.724900
-vn -0.269900 0.421500 -0.865700
-vn -0.395600 0.336800 -0.854500
-vn 0.000000 0.797100 -0.603900
-vn -0.142400 0.274900 -0.950900
-vn -0.056900 0.142700 -0.988100
-vn -0.056900 -0.142700 -0.988100
-vn -0.142400 -0.274900 -0.950900
-vn -0.247900 0.000000 -0.968700
-vn 0.000000 -0.688800 -0.724900
-vn 0.000000 -0.797100 -0.603900
-vn -0.395600 -0.336800 -0.854500
-vn -0.269900 -0.421500 -0.865700
-vn 0.440000 0.000000 -0.898000
-vn 0.269900 0.421500 -0.865700
-vn 0.395600 0.336800 -0.854500
-vn 0.550800 0.000000 -0.834600
-vn -0.440000 0.000000 -0.898000
-vn -0.550800 0.000000 -0.834600
-vn 0.056900 -0.142700 -0.988100
-vn 0.056900 0.142700 -0.988100
-vn 0.142400 -0.274900 -0.950900
-vn 0.000000 -0.450200 -0.892900
-vn 0.142400 0.274900 -0.950900
-vn 0.247900 0.000000 -0.968700
-vn 0.000000 0.450200 -0.892900
-vn 0.269900 -0.421500 -0.865700
-vn 0.395600 -0.336800 -0.854500
-s off
-f 1/1/1 29/2/1 30/3/1 4/4/1
-f 8/5/2 5/6/2 31/7/2 32/8/2
-f 32/8/3 31/9/3 30/10/3 29/1/3
-f 8/2/4 1/5/4 4/11/4 5/12/4
-f 18/13/5 15/14/5 10/15/5 11/16/5
-f 19/17/6 18/18/6 11/19/6 12/20/6
-f 21/21/7 24/22/7 23/23/7 22/24/7
-f 25/25/8 26/26/8 27/27/8 28/28/8
-f 19/29/9 12/30/9 9/31/9 14/32/9
-f 22/26/10 23/21/10 27/22/10 26/27/10
-f 21/33/11 22/21/11 26/26/11 25/34/11
-f 24/22/12 28/27/12 27/35/12 23/36/12
-f 34/37/13 36/38/13 8/39/13 32/40/13
-f 33/41/13 34/37/13 32/40/13 29/42/13
-f 33/41/13 29/42/13 1/43/13 35/44/13
-f 35/44/13 1/43/13 8/39/13 36/38/13
-f 45/45/12 40/46/12 41/47/12 42/48/12 46/49/12
-f 48/50/11 47/51/11 43/52/11 44/53/11 38/54/11
-f 44/55/8 43/45/8 42/51/8 41/56/8 37/57/8
-f 48/47/7 39/58/7 45/52/7 46/59/7 47/60/7
-f 12/13/8 11/30/8 10/31/8 9/14/8
-f 19/29/7 14/32/7 15/61/7 18/62/7
-f 16/63/13 20/64/13 7/65/13 3/66/13
-f 13/67/13 16/63/13 3/66/13 2/68/13
-f 17/69/13 6/70/13 7/65/13 20/64/13
-f 13/67/13 2/68/13 6/70/13 17/69/13
-s 1
-f 73/71/14 72/72/15 52/44/16 61/73/17
-f 56/74/18 60/75/19 59/76/20 55/77/21 69/78/22
-f 74/79/23 63/80/24 51/37/25 66/81/26
-f 75/82/27 70/83/28 50/38/29 62/84/30
-f 76/85/31 64/86/32 52/41/16 72/87/15
-f 57/88/33 59/76/20 60/75/19 58/89/34
-f 55/77/21 59/76/20 57/88/33 53/90/35 68/91/36
-f 53/90/35 57/88/33 58/89/34 54/92/37 67/93/38
-f 54/92/37 58/89/34 60/75/19 56/74/18 65/94/39
-f 65/94/39 56/92/18 72/72/15 73/71/14
-f 54/74/37 65/94/39 73/71/14 70/87/28
-f 70/87/28 73/71/14 61/73/17 50/41/29
-f 68/91/36 74/79/23 66/81/26 55/77/21
-f 53/90/35 71/83/40 74/79/23 68/91/36
-f 71/83/40 49/38/41 63/80/24 74/79/23
-f 67/93/38 54/90/37 70/83/28 75/82/27
-f 53/92/35 67/93/38 75/82/27 71/72/40
-f 71/72/40 75/82/27 62/84/30 49/44/41
-f 69/78/22 76/85/31 72/87/15 56/74/18
-f 55/77/21 66/81/26 76/85/31 69/78/22
-f 66/81/26 51/37/25 64/86/32 76/85/31