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.

.gitignore

@@ -1,3 +1 @@
 *~
-*.patch
-*.diff

COPYING.txt

@@ -1,30 +0,0 @@
-The Mesecons Mod for Minetest is
-	Copyright (C) 2011-2016 Mesecons Mod Developer Team and contributors
-
-See the version control system log for information about other authors.
-
-License of source code
-----------------------
-Copyright (C) 2011-2016 Mesecons Mod Developer Team and contributors
-
-This program is free software; you can redistribute the Mesecons Mod and/or
-modify it under the terms of the GNU Lesser General Public License version 3
-published by the Free Software Foundation.
-
-This library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-Library General Public License for more details.
-
-You should have received a copy of the GNU Library General Public
-License along with this library; if not, write to the
-Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
-Boston, MA  02110-1301, USA.
-
-License of media (textures, sounds and documentation)
------------------------------------------------------
-Copyright (C) 2011-2016 Mesecons Mod Developer Team and contributors
-
-All textures, sounds and documentation files are licensed under the
-Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
-http://creativecommons.org/licenses/by-sa/3.0/

README.md

@@ -22,9 +22,9 @@ OK, I want in.
 --------------
 Go get it!
 
-[DOWNLOAD IT NOW](https://github.com/minetest-mods/mesecons/archive/master.zip)
+[DOWNLOADS PAGE](http://mesecons.net/downloads.php)
 
-Now go ahead and install it like any other Minetest mod. Don't know how? Check out [the wonderful page about it](https://wiki.minetest.net/Mods) over at the official Minetest Wiki. For your convenience, here's a quick summary:
+Now go ahead and install it like any other Minetest mod. Don't know how? Check out [the wonderful page about it](http://wiki.minetest.com/wiki/Mods) over at the Minetest Wiki. For your convenience, here's a quick summary:
 
 1. If Mesecons is still in a ZIP file, extract the folder inside to somewhere on the computer.
 2. Make sure that when you open the folder, you can directly find `README.md` in the listing. If you just see another folder, move that folder up one level and delete the old one.
@@ -39,15 +39,13 @@ How do I use this thing?
 ------------------------
 How about a [quick overview video](https://www.youtube.com/watch?v=6kmeQj6iW5k)?
 
-Or maybe a [comprehensive reference](http://mesecons.net/items.html) is your style?
+Or maybe a [comprehensive reference](http://mesecons.net/items.php) is your style?
 
 An overview for the very newest of new beginners? How does [this one](http://uberi.mesecons.net/projects/MeseconsBasics/index.html) look?
 
-There is also a [wiki page](https://wiki.minetest.net/Mods/Mesecons) dedicated to this mod.
-
 Want to get more into building? Why not check out the [Mesecons Laboratory](http://uberi.mesecons.net/), a website dedicated to advanced Mesecons builders?
 
-Want to contribute to Mesecons itself? Check out the [source code](https://github.com/minetest-mods/mesecons)!
+Want to contribute to Mesecons itself? Check out the [source code](https://github.com/Jeija/minetest-mod-mesecons)!
 
 Who wrote it anyways?
 ---------------------
@@ -55,7 +53,6 @@ These awesome people made Mesecons possible!
 
 | Contributor     | Contribution                     |
 | --------------- | -------------------------------- |
-| Hawk777         | Code for VoxelManip caching      |
 | Jat15           | Various tweaks.                  |
 | Jeija           | **Main developer! Everything.**  |
 | Jordach         | Noteblock sounds.                |

bower.json

@@ -1,12 +0,0 @@
-{
-    "name": "mesecons",
-    "description": "Mesecons is a mod for Minetest that implements items related to digital circuitry: wires, buttons, lights, and programmable controllers.",
-    "homepage": "http://mesecons.net",
-    "authors": "Jeija",
-    "license": "LGPL-3.0+",
-    "keywords": [
-        "mesecons",
-        "minetest",
-        "mod"
-    ]
-}

documentation.json

@@ -1,64 +0,0 @@
-{
-	"Conductors" : {
-		"Mesecon" : "mesecons_wires/doc/mesecon",
-		"Insulated Wire" : "mesecons_insulated/doc/insulated",
-		"T-Junction" : "mesecons_extrawires/doc/tjunction",
-		"Crossing" : "mesecons_extrawires/doc/crossing",
-		"Corner" : "mesecons_extrawires/doc/corner",
-		"Vertical Wire" : "mesecons_extrawires/doc/vertical",
-		"Mese" : "mesecons_extrawires/doc/mese"
-	},
-	"Receptors" : {
-		"Power Plant" : "mesecons_powerplant/doc/powerplant",
-		"Blinky Plant" : "mesecons_blinkyplant/doc/blinkyplant",
-		"Switch" : "mesecons_switch/doc/switch",
-		"Object Detector" : "mesecons_detector/doc/objectdetector",
-		"Node Detector" : "mesecons_detector/doc/nodedetector",
-		"Wall Lever" : "mesecons_walllever/doc/walllever",
-		"Pressure Plate" : "mesecons_pressureplates/doc/pressureplate_wood",
-		"Pressure Plate" : "mesecons_pressureplates/doc/pressureplate_stone",
-		"Water Turbine" : "mesecons_hydroturbine/doc/waterturbine",
-		"Solar Panel" : "mesecons_solarpanel/doc/solarpanel",
-		"Wall Button" : "mesecons_button/doc/button"
-	},
-	"Effectors" : {
-		"Noteblock" : "mesecons_noteblock/doc/noteblock",
-		"Lamp" : "mesecons_lamp/doc/lamp",
-		"Piston" : "mesecons_pistons/doc/piston",
-		"Sticky Piston" : "mesecons_pistons/doc/piston_sticky",
-		"Movestone" : "mesecons_movestones/doc/movestone",
-		"Sticky Movestone" : "mesecons_movestones/doc/movestone_sticky",
-		"Removestone" : "mesecons_random/doc/removestone",
-		"Ghoststone" : "mesecons_random/doc/ghoststone",
-		"Command Block" : "mesecons_commandblock/doc/commandblock",
-		"Lightstones" : {
-			"Dark Grey" : "mesecons_lightstone/doc/lightstone_darkgrey",
-			"Light Grey" : "mesecons_lightstone/doc/lightstone_lightgrey",
-			"Green" : "mesecons_lightstone/doc/lightstone_green",
-			"Red" : "mesecons_lightstone/doc/lightstone_red",
-			"Blue" : "mesecons_lightstone/doc/lightstone_blue",
-			"Yellow" : "mesecons_lightstone/doc/lightstone_yellow"
-		}
-	},
-	"Logic" : {
-		"Luacontroller" : "mesecons_luacontroller/doc/luacontroller",
-		"FPGA" : "mesecons_fpga/doc/fpga",
-		"FPGA Programmer" : "mesecons_fpga/doc/programmer",
-		"Torch" : "mesecons_torch/doc/torch",
-		"Delayer" : "mesecons_delayer/doc/delayer",
-		"Gates" : {
-			"Diode" : "mesecons_gates/doc/diode",
-			"NOT Gate" : "mesecons_gates/doc/not",
-			"AND Gate" : "mesecons_gates/doc/and",
-			"NAND Gate" : "mesecons_gates/doc/nand",
-			"OR Gate" : "mesecons_gates/doc/or",
-			"NOR Gate" : "mesecons_gates/doc/nor",
-			"XOR Gate" : "mesecons_gates/doc/xor"
-		}
-	},
-	"Crafts" : {
-		"Silicon" : "mesecons_materials/doc/silicon",
-		"Glue" : "mesecons_materials/doc/glue",
-		"Fiber" : "mesecons_materials/doc/fiber"
-	}
-}

mesecons/VERSION

@@ -0,0 +1 @@
+0.41 DEV

mesecons/actionqueue.lua

@@ -1,149 +1,114 @@
---[[
+mesecon.queue.actions={} -- contains all ActionQueue actions
-Mesecons uses something it calls an ActionQueue.
 
-The ActionQueue holds functions and actions.
+function mesecon.queue:add_function(name, func)
-Functions are added on load time with a specified name.
+	mesecon.queue.funcs[name] = func
-Actions are preserved over server restarts.
-
-Each action consists of a position, the name of an added function to be called,
-the params that should be used in this function call (additionally to the pos),
-the time after which it should be executed, an optional overwritecheck and a
-priority.
-
-If time = 0, the action will be executed in the next globalstep, otherwise the
-earliest globalstep when it will be executed is the after next globalstep.
-
-It is guaranteed, that for two actions ac1, ac2 where ac1 ~= ac2,
-ac1.time == ac2.time, ac1.priority == ac2.priority and ac1 was added earlier
-than ac2, ac1 will be executed before ac2 (but in the same globalstep).
-
-Note: Do not pass references in params, as they can not be preserved.
-
-Also note: Some of the guarantees here might be dropped at some time.
-]]
-
-
--- localize for speed
-local queue = mesecon.queue
-
-queue.actions = {} -- contains all ActionQueue actions
-
-function queue:add_function(name, func)
-	queue.funcs[name] = func
 end
 
 -- If add_action with twice the same overwritecheck and same position are called, the first one is overwritten
 -- use overwritecheck nil to never overwrite, but just add the event to the queue
 -- priority specifies the order actions are executed within one globalstep, highest first
 -- should be between 0 and 1
-function queue:add_action(pos, func, params, time, overwritecheck, priority)
+function mesecon.queue:add_action(pos, func, params, time, overwritecheck, priority)
 	-- Create Action Table:
 	time = time or 0 -- time <= 0 --> execute, time > 0 --> wait time until execution
 	priority = priority or 1
-	local action = {
+	local action = {	pos=mesecon:tablecopy(pos),
-		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
+				priority=priority}
-	}
 
-	 -- check if old action has to be overwritten / removed:
+	local toremove = nil
-	if overwritecheck then
+	-- Otherwise, add the action to the queue
-		for i, ac in ipairs(queue.actions) do
+	if overwritecheck then -- check if old action has to be overwritten / removed:
-			if vector.equals(pos, ac.pos)
+		for i, ac in ipairs(mesecon.queue.actions) do
-					and mesecon.cmpAny(overwritecheck, ac.owcheck) then
+			if(mesecon:cmpPos(pos, ac.pos)
-				-- remove the old action
+			and mesecon:cmpAny(overwritecheck, ac.owcheck)) then
-				table.remove(queue.actions, i)
+				toremove = i
 				break
 			end
 		end
 	end
 
-	table.insert(queue.actions, action)
+	if (toremove ~= nil) then
+		table.remove(mesecon.queue.actions, toremove)
+	end
+
+	table.insert(mesecon.queue.actions, action)
 end
 
 -- execute the stored functions on a globalstep
 -- if however, the pos of a function is not loaded (get_node_or_nil == nil), do NOT execute the function
--- this makes sure that resuming mesecons circuits when restarting minetest works fine (hm, where do we do this?)
+-- this makes sure that resuming mesecons circuits when restarting minetest works fine
 -- However, even that does not work in some cases, that's why we delay the time the globalsteps
--- start to be execute by 4 seconds
+-- start to be execute by 5 seconds
+local get_highest_priority = function (actions)
+	local highestp = -1, highesti
+	for i, ac in ipairs(actions) do
+		if ac.priority > highestp then
+			highestp = ac.priority
+			highesti = i
+		end
+	end
 
-local function globalstep_func(dtime)
+	return highesti
-	local actions = queue.actions
+end
-	-- split into two categories:
+
-	-- actions_now: actions to execute now
+local m_time = 0
-	-- queue.actions: actions to execute later
+minetest.register_globalstep(function (dtime)
+	m_time = m_time + dtime
+	if (m_time < MESECONS_RESUMETIME) then return end -- don't even try if server has not been running for XY seconds
+	local actions = mesecon:tablecopy(mesecon.queue.actions)
 	local actions_now={}
-	queue.actions = {}
 
-	for _, ac in ipairs(actions) do
+	mesecon.queue.actions = {}
+
+	-- sort actions into two categories:
+	-- those toexecute now (actions_now) and those to execute later (mesecon.queue.actions)
+	for i, ac in ipairs(actions) do
 		if ac.time > 0 then
-			-- action ac is to be executed later
+			ac.time = ac.time - dtime -- executed later
-			-- ~> insert into queue.actions
+			table.insert(mesecon.queue.actions, ac)
-			ac.time = ac.time - dtime
-			table.insert(queue.actions, ac)
 		else
-			-- action ac is to be executed now
-			-- ~> insert into actions_now
 			table.insert(actions_now, ac)
 		end
 	end
 
-	-- stable-sort the executed actions after their priority
+	while(#actions_now > 0) do -- execute highest priorities first, until all are executed
-	-- some constructions might depend on the execution order, hence we first
+		local hp = get_highest_priority(actions_now)
-	-- execute the actions that had a lower index in actions_now
+		mesecon.queue:execute(actions_now[hp])
-	local old_action_order = {}
+		table.remove(actions_now, hp)
-	for i, ac in ipairs(actions_now) do
-		old_action_order[ac] = i
-	end
-	table.sort(actions_now, function(ac1, ac2)
-		if ac1.priority ~= ac2.priority then
-			return ac1.priority > ac2.priority
-		else
-			return old_action_order[ac1] < old_action_order[ac2]
 	end
 end)
 
-	-- execute highest priorities first, until all are executed
+function mesecon.queue:execute(action)
-	for _, ac in ipairs(actions_now) do
+	mesecon.queue.funcs[action.func](action.pos, unpack(action.params))
-		queue:execute(ac)
-	end
-end
-
--- delay the time the globalsteps start to be execute by 4 seconds
-do
-	local m_time = 0
-	local resumetime = mesecon.setting("resumetime", 4)
-	local globalstep_func_index = #minetest.registered_globalsteps + 1
-
-	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
-		-- replace this globalstep function
-		minetest.registered_globalsteps[globalstep_func_index] = globalstep_func
-	end)
-end
-
-function queue:execute(action)
-	-- ignore if action queue function name doesn't exist,
-	-- (e.g. in case the action queue savegame was written by an old mesecons version)
-	if queue.funcs[action.func] then
-		queue.funcs[action.func](action.pos, unpack(action.params))
-	end
 end
 
 
 -- Store and read the ActionQueue to / from a file
 -- so that upcoming actions are remembered when the game
 -- is restarted
-queue.actions = mesecon.file2table("mesecon_actionqueue")
+
+local wpath = minetest.get_worldpath()
+local function file2table(filename)
+	local f = io.open(filename, "r")
+	if f==nil then return {} end
+	local t = f:read("*all")
+	f:close()
+	if t=="" or t==nil then return {} end
+	return minetest.deserialize(t)
+end
+
+local function table2file(filename, table)
+	local f = io.open(filename, "w")
+	f:write(minetest.serialize(table))
+	f:close()
+end
+
+mesecon.queue.actions = file2table(wpath.."/mesecon_actionqueue")
 
 minetest.register_on_shutdown(function()
-	mesecon.table2file("mesecon_actionqueue", queue.actions)
+	mesecon.queue.actions = table2file(wpath.."/mesecon_actionqueue", mesecon.queue.actions)
 end)

mesecons/depends.txt

@@ -0,0 +1 @@
+default

mesecons/init.lua

@@ -3,7 +3,7 @@
 -- |  \/  | |___ ____  |___ |      |    | | \  | |____
 -- |      | |        | |    |      |    | |  \ |     |
 -- |      | |___ ____| |___ |____  |____| |   \| ____|
--- by Jeija, Uberi (Temperest), sfan5, VanessaE, Hawk777 and contributors
+-- by Jeija, Uberi (Temperest), sfan5, VanessaE
 --
 --
 --
@@ -11,7 +11,7 @@
 -- See the documentation on the forum for additional information, especially about crafting
 --
 --
--- For basic development resources, see http://mesecons.net/developers.html
+-- For developer documentation see the Developers' section on mesecons.TK
 --
 --
 --
@@ -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,63 +67,75 @@ 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
 
 mesecon.queue:add_function("receptor_on", function (pos, rules)
-	mesecon.vm_begin()
-
 	rules = rules or mesecon.rules.default
 
-	-- Call turnon on all linking positions
+	-- 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
+	for _, rule in ipairs(mesecon:flattenrules(rules)) do
-		local np = vector.add(pos, rule)
+		local np = mesecon:addPosRule(pos, rule)
-		local rulenames = mesecon.rules_link_rule_all(pos, rule)
+		-- if area is not loaded, keep trying
-		for _, rulename in ipairs(rulenames) do
+		if minetest.get_node_or_nil(np) == nil then
-			mesecon.turnon(np, rulename)
+			mesecon.queue:add_action(pos, "receptor_on", {rules}, nil, rules)
+			return
 		end
 	end
 
-	mesecon.vm_commit()
+	-- 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 _, rulename in ipairs(rulenames) do
+			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
 
 mesecon.queue:add_function("receptor_off", function (pos, rules)
 	rules = rules or mesecon.rules.default
 
-	-- Call turnoff on all linking positions
+	-- 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
+	for _, rule in ipairs(mesecon:flattenrules(rules)) do
-		local np = vector.add(pos, rule)
+		local np = mesecon:addPosRule(pos, rule)
-		local rulenames = mesecon.rules_link_rule_all(pos, rule)
+		if minetest.get_node_or_nil(np) == nil then
-		for _, rulename in ipairs(rulenames) do
+			mesecon.queue:add_action(pos, "receptor_off", {rules}, nil, rules)
-			mesecon.vm_begin()
+			return
-			mesecon.changesignal(np, minetest.get_node(np), rulename, mesecon.state.off, 2)
+		end
+	end
 
-			-- Turnoff returns true if turnoff process was successful, no onstate receptor
+	for _, rule in ipairs(mesecon:flattenrules(rules)) do
-			-- was found along the way. Commit changes that were made in voxelmanip. If turnoff
+		local np = mesecon:addPosRule(pos, rule)
-			-- returns true, an onstate receptor was found, abort voxelmanip transaction.
+		local rulenames = mesecon:rules_link_rule_all(pos, rule)
-			if (mesecon.turnoff(np, rulename)) then
+		for _, rulename in ipairs(rulenames) do
-				mesecon.vm_commit()
+			if not mesecon:connected_to_receptor(np, mesecon:invertRule(rule)) then
+				mesecon:turnoff(np, rulename)
 			else
-				mesecon.vm_abort()
+				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
+--The actual wires
--- To be removed in future releases
+dofile(minetest.get_modpath("mesecons").."/wires.lua");
-dofile(minetest.get_modpath("mesecons").."/legacy.lua");
 
 --Services like turnoff receptor on dignode and so on
 dofile(minetest.get_modpath("mesecons").."/services.lua");

mesecons/internal.lua

@@ -1,53 +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_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_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_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_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_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(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_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: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: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(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_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: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: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: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, depth)				--> Deactivates the effector node at the specific pos (calls nodedef.mesecons.effector.action_off), higher depths 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, depth)	--> Changes     the effector node at the specific pos (calls nodedef.mesecons.effector.action_change), higher depths are executed later
+-- 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(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_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: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_on(node_off) --> Returns the onstate  nodename of the conductor
--- mesecon.get_conductor_off(node_on)	--> Returns the offstate 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: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_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:is_power_off(pos)            --> Returns true if pos does not emit power in any way
--- mesecon.is_powered(pos)				--> Returns true if pos is powered by a receptor or a conductor
+-- 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
+-- RULES ROTATION helpsers
--- mesecon.rotate_rules_right(rules)
+-- mesecon:rotate_rules_right(rules)
--- mesecon.rotate_rules_left(rules)
+-- mesecon:rotate_rules_left(rules)
--- mesecon.rotate_rules_up(rules)
+-- mesecon:rotate_rules_up(rules)
--- mesecon.rotate_rules_down(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
@@ -55,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
@@ -63,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
@@ -71,59 +80,52 @@ function mesecon.get_conductor(nodename)
 	end
 end
 
-function mesecon.get_any_outputrules(node)
+function mesecon:get_any_outputrules (node)
-	if not node then return nil end
+	if mesecon:is_conductor(node.name) then
-
+		return mesecon:conductor_get_rules(node)
-	if mesecon.is_conductor(node.name) then
+	elseif mesecon:is_receptor(node.name) then
-		return mesecon.conductor_get_rules(node)
+		return mesecon:receptor_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)
+function mesecon:get_any_inputrules (node)
-	if not node then return nil end
+	if mesecon:is_conductor(node.name) then
-
+		return mesecon:conductor_get_rules(node)
-	if mesecon.is_conductor(node.name) then
+	elseif mesecon:is_effector(node.name) then
-		return mesecon.conductor_get_rules(node)
+		return mesecon:effector_get_rules(node)
-	elseif mesecon.is_effector(node.name) then
-		return mesecon.effector_get_rules(node)
 	end
-end
+	return false
-
-function mesecon.get_any_rules(node)
-	return mesecon.mergetable(mesecon.get_any_inputrules(node) or {},
-		mesecon.get_any_outputrules(node) or {})
 end
 
 -- Receptors
 -- Nodes that can power mesecons
-function mesecon.is_receptor_on(nodename)
+function mesecon:is_receptor_on(nodename)
-	local receptor = mesecon.get_receptor(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)
+function mesecon:is_receptor_off(nodename)
-	local receptor = mesecon.get_receptor(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)
+function mesecon:is_receptor(nodename)
-	local receptor = mesecon.get_receptor(nodename)
+	local receptor = mesecon:get_receptor(nodename)
 	if receptor then
 		return true
 	end
 	return false
 end
 
-function mesecon.receptor_get_rules(node)
+function mesecon:receptor_get_rules(node)
-	local receptor = mesecon.get_receptor(node.name)
+	local receptor = mesecon:get_receptor(node.name)
 	if receptor then
 		local rules = receptor.rules
 		if type(rules) == 'function' then
@@ -138,32 +140,32 @@ end
 
 -- Effectors
 -- Nodes that can be powered by mesecons
-function mesecon.is_effector_on(nodename)
+function mesecon:is_effector_on(nodename)
-	local effector = mesecon.get_effector(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)
+function mesecon:is_effector_off(nodename)
-	local effector = mesecon.get_effector(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)
+function mesecon:is_effector(nodename)
-	local effector = mesecon.get_effector(nodename)
+	local effector = mesecon:get_effector(nodename)
 	if effector then
 		return true
 	end
 	return false
 end
 
-function mesecon.effector_get_rules(node)
+function mesecon:effector_get_rules(node)
-	local effector = mesecon.get_effector(node.name)
+	local effector = mesecon:get_effector(node.name)
 	if effector then
 		local rules = effector.rules
 		if type(rules) == 'function' then
@@ -181,162 +183,159 @@ end
 
 -- Activation:
 mesecon.queue:add_function("activate", function (pos, rulename)
-	local node = mesecon.get_node_force(pos)
+	node = minetest.get_node(pos)
-	if not node then return end
+	effector = mesecon:get_effector(node.name)
-
-	local 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
+		for _,rule in ipairs(mesecon:effector_get_rules(node)) do
-			mesecon.activate(pos, node, rule, depth + 1)
+			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 = mesecon.get_node_force(pos)
+	node = minetest.get_node(pos)
-	if not node then return end
+	effector = mesecon:get_effector(node.name)
-
-	local 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
+		for _,rule in ipairs(mesecon:effector_get_rules(node)) do
-			mesecon.deactivate(pos, node, rule, depth + 1)
+			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 = mesecon.get_node_force(pos)
+	node = minetest.get_node(pos)
-	if not node then return end
+	effector = mesecon:get_effector(node.name)
-
-	local effector = mesecon.get_effector(node.name)
 
 	if effector and effector.action_change then
 		effector.action_change(pos, node, rulename, changetype)
 	end
 end)
 
-function mesecon.changesignal(pos, node, rulename, newstate, depth)
+function mesecon:changesignal(pos, node, rulename, newstate, recdepth)
 	if rulename == nil then
-		for _,rule in ipairs(mesecon.effector_get_rules(node)) do
+		for _,rule in ipairs(mesecon:effector_get_rules(node)) do
-			mesecon.changesignal(pos, node, rule, newstate, depth + 1)
+			mesecon:changesignal(pos, node, rule, newstate, recdepth + 1)
 		end
 		return
 	end
 
-	-- Include "change" in overwritecheck so that it cannot be overwritten
+	mesecon.queue:add_action(pos, "change", {rulename, newstate}, nil, rulename, 1 / recdepth)
-	-- by "active" / "deactivate" that will be called upon the node at the same time.
+end
-	local overwritecheck = {"change", rulename}
+
-	mesecon.queue:add_action(pos, "change", {rulename, newstate}, nil, overwritecheck, 1 / depth)
+-- #########
+-- # 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)
+function mesecon:is_conductor_on(node, rulename)
-	if not node then return false end
+	local conductor = mesecon:get_conductor(node.name)
-
-	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 bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node))
-			local binstate = mesecon.getbinstate(node.name, conductor.states)
+			local binstate = mesecon:getbinstate(node.name, conductor.states)
-			return mesecon.get_bit(binstate, bit)
+			return mesecon:get_bit(binstate, bit)
 		end
 	end
-
 	return false
 end
 
-function mesecon.is_conductor_off(node, rulename)
+function mesecon:is_conductor_off(node, rulename)
-	if not node then return false end
+	local conductor = mesecon:get_conductor(node.name)
-
-	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 bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node))
-			local binstate = mesecon.getbinstate(node.name, conductor.states)
+			local binstate = mesecon:getbinstate(node.name, conductor.states)
-			return not mesecon.get_bit(binstate, bit)
+			return not mesecon:get_bit(binstate, bit)
 		end
 	end
-
 	return false
 end
 
-function mesecon.is_conductor(nodename)
+function mesecon:is_conductor(nodename)
-	local conductor = mesecon.get_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)
+function mesecon:get_conductor_on(node_off, rulename)
-	local conductor = mesecon.get_conductor(node_off.name)
+	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 bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node_off))
-			local binstate = mesecon.getbinstate(node_off.name, conductor.states)
+			local binstate = mesecon:getbinstate(node_off.name, conductor.states)
-			binstate = mesecon.set_bit(binstate, bit, "1")
+			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)
+function mesecon:get_conductor_off(node_on, rulename)
-	local conductor = mesecon.get_conductor(node_on.name)
+	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 bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node_on))
-			local binstate = mesecon.getbinstate(node_on.name, conductor.states)
+			local binstate = mesecon:getbinstate(node_on.name, conductor.states)
-			binstate = mesecon.set_bit(binstate, bit, "0")
+			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)
+function mesecon:conductor_get_rules(node)
-	local conductor = mesecon.get_conductor(node.name)
+	local conductor = mesecon:get_conductor(node.name)
 	if conductor then
 		local rules = conductor.rules
 		if type(rules) == 'function' then
@@ -350,201 +349,356 @@ end
 
 -- some more general high-level stuff
 
-function mesecon.is_power_on(pos, rulename)
+function mesecon:is_power_on(pos, rulename)
-	local node = mesecon.get_node_force(pos)
+	local node = minetest.get_node(pos)
-	if node and (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 = mesecon.get_node_force(pos)
+	local node = minetest.get_node(pos)
-	if node and (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
 
--- Turn off an equipotential section starting at `pos`, which outputs in the direction of `link`.
+function mesecon:turnon(pos, rulename, recdepth)
--- Breadth-first search. Map is abstracted away in a voxelmanip.
+	recdepth = recdepth or 2
--- Follow all all conductor paths replacing conductors that were already
+	local node = minetest.get_node(pos)
--- looked at, activating / changing all effectors along the way.
-function mesecon.turnon(pos, link)
-	local frontiers = {{pos = pos, link = link}}
 
-	local depth = 1
+	if(node.name == "ignore") then
-	while frontiers[1] do
+		-- try turning on later again
-		local f = table.remove(frontiers, 1)
+		mesecon.queue:add_action(
-		local node = mesecon.get_node_force(f.pos)
+			pos, "turnon", {rulename, recdepth + 1}, nil, true)
+	end
 	
-		if not node then
+	if mesecon:is_conductor_off(node, rulename) then
-			-- Area does not exist; do nothing
+		local rules = mesecon:conductor_get_rules(node)
-		elseif mesecon.is_conductor_off(node, f.link) then
-			local rules = mesecon.conductor_get_rules(node)
 
-			-- Call turnon on neighbors
+		if not rulename then
-			for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
+			for _, rule in ipairs(mesecon:flattenrules(rules)) do
-				local np = vector.add(f.pos, r)
+				if mesecon:connected_to_receptor(pos, rule) then
-				for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
+					mesecon:turnon(pos, rule, recdepth + 1)
-					table.insert(frontiers, {pos = np, link = l})
+				end
+			end
+			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
+	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.swap_node_force(f.pos, mesecon.get_conductor_on(node, f.link))
+mesecon.queue:add_function("turnon", function (pos, rulename, recdepth)
-		elseif mesecon.is_effector(node.name) then
+	mesecon:turnon(pos, rulename, recdepth)
-			mesecon.changesignal(f.pos, node, f.link, mesecon.state.on, depth)
+end)
-			if mesecon.is_effector_off(node.name) then
+
-				mesecon.activate(f.pos, node, f.link, depth)
+function mesecon:turnoff(pos, rulename, recdepth)
+	recdepth = recdepth or 2
+	local node = minetest.get_node(pos)
+
+	if(node.name == "ignore") then
+		-- try turning on later again
+		mesecon.queue:add_action(
+			pos, "turnoff", {rulename, recdepth + 1}, nil, true)
+	end
+
+	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})
+
+		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)
+
+				for _, rulename in ipairs(rulenames) do
+					mesecon:turnoff(np, rulename, recdepth + 1)
 				end
 			end
-		depth = depth + 1
+		end
+	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
 
--- Turn on an equipotential section starting at `pos`, which outputs in the direction of `link`.
+mesecon.queue:add_function("turnoff", function (pos, rulename, recdepth)
--- Breadth-first search. Map is abstracted away in a voxelmanip.
+	mesecon:turnoff(pos, rulename, recdepth)
--- Follow all all conductor paths replacing conductors that were already
+end)
--- looked at, deactivating / changing all effectors along the way.
--- In case an onstate receptor is discovered, abort the process by returning false, which will
--- cause `receptor_off` to discard all changes made in the voxelmanip.
--- Contrary to turnon, turnoff has to cache all change and deactivate signals so that they will only
--- be called in the very end when we can be sure that no conductor was found along the path.
---
--- Signal table entry structure:
--- {
---	pos = position of effector,
---	node = node descriptor (name, param1 and param2),
---	link = link the effector is connected to,
---	depth = indicates order in which signals wire fired, higher is later
--- }
-function mesecon.turnoff(pos, link)
-	local frontiers = {{pos = pos, link = link}}
-	local signals = {}
 
-	local depth = 1
-	while frontiers[1] do
-		local f = table.remove(frontiers, 1)
-		local node = mesecon.get_node_force(f.pos)
 
-		if not node then
+function mesecon:connected_to_receptor(pos, rulename)
-			-- Area does not exist; do nothing
+	local node = minetest.get_node(pos)
-		elseif mesecon.is_conductor_on(node, f.link) then
+
-			local rules = mesecon.conductor_get_rules(node)
+	-- Check if conductors around are connected
-			for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
+	local rules = mesecon:get_any_inputrules(node)
-				local np = vector.add(f.pos, r)
+	if not rules then return false end
+
+	for _, rule in ipairs(mesecon:rule2meta(rulename, rules)) do
+		local rulenames = mesecon:rules_link_rule_all_inverted(pos, rule)
+		for _, 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
+	end
 
-				-- Check if an onstate receptor is connected. If that is the case,
-				-- abort this turnoff process by returning false. `receptor_off` will
-				-- discard all the changes that we made in the voxelmanip:
-				for _, l in ipairs(mesecon.rules_link_rule_all_inverted(f.pos, r)) do
-					if mesecon.is_receptor_on(mesecon.get_node_force(np).name) then
 	return false
 end
-				end
 
-				-- Call turnoff on neighbors
+function mesecon:find_receptor_on(pos, checked, rulename)
-				for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
+	local node = minetest.get_node(pos)
-					table.insert(frontiers, {pos = np, link = l})
-				end
-			end
-
-			mesecon.swap_node_force(f.pos, mesecon.get_conductor_off(node, f.link))
-		elseif mesecon.is_effector(node.name) then
-			table.insert(signals, {
-				pos = f.pos,
-				node = node,
-				link = f.link,
-				depth = depth
-			})
-		end
-		depth = depth + 1
-	end
-
-	for _, sig in ipairs(signals) do
-		mesecon.changesignal(sig.pos, sig.node, sig.link, mesecon.state.off, sig.depth)
-		if mesecon.is_effector_on(sig.node.name) and not mesecon.is_powered(sig.pos) then
-			mesecon.deactivate(sig.pos, sig.node, sig.link, sig.depth)
-		end
-	end
 
+	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
 
--- Get all linking inputrules of inputnode (effector or conductor) that is connected to
+	if mesecon:is_conductor(node.name) then
--- outputnode (receptor or conductor) at position `output` and has an output in direction `rule`
+		local rules = mesecon:conductor_get_rules(node)
-function mesecon.rules_link_rule_all(output, rule)
+		local metaindex = mesecon:rule2metaindex(rulename, rules)
-	local input = vector.add(output, rule)
+		-- find out if node has already been checked (to prevent from endless loop)
-	local inputnode = mesecon.get_node_force(input)
+		for _, cp in ipairs(checked) do
-	local inputrules = mesecon.get_any_inputrules(inputnode)
+			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
+	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
+	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)
+	if not outputrules or not inputrules then
+		return
+	end
+
+	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
+				-- Check if input accepts from output
+				if  mesecon:cmpPos(mesecon:addPosRule(input, inputrule), output) then
+					if inputrule.sx == nil or outputrule.sx == nil or mesecon:cmpSpecial(inputrule, outputrule) then
+						return true, inputrule
+					end
+				end
+			end
+		end
+	end
+	return false
+end
+
+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)
 	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  vector.equals(vector.add(input, inputrule), output) then
+		if  mesecon:cmpPos(mesecon:addPosRule(input, inputrule), output) then
-			table.insert(rules, inputrule)
+			if inputrule.sx == nil or rule.sx == nil or mesecon:cmpSpecial(inputrule, rule) then
+				rules[#rules+1] = inputrule
+			end
 		end
 	end
-
 	return rules
 end
 
--- Get all linking outputnodes of outputnode (receptor or conductor) that is connected to
+function mesecon:rules_link_rule_all_inverted(input, rule)
--- inputnode (effector or conductor) at position `input` and has an input in direction `rule`
+	--local irule = mesecon:invertRule(rule)
-function mesecon.rules_link_rule_all_inverted(input, rule)
+	local output = mesecon:addPosRule(input, rule)
-	local output = vector.add(input, rule)
+	local outputnode = minetest.get_node(output)
-	local outputnode = mesecon.get_node_force(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
+	for _, outputrule in ipairs(mesecon:flattenrules(outputrules)) do
-		if  vector.equals(vector.add(output, outputrule), input) then
+		if  mesecon:cmpPos(mesecon:addPosRule(output, outputrule), input) then
-			table.insert(rules, mesecon.invertRule(outputrule))
+			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.is_powered(pos, rule)
+function mesecon:rules_link_anydir(pos1, pos2)
-	local node = mesecon.get_node_force(pos)
+	return mesecon:rules_link(pos1, pos2) or mesecon:rules_link(pos2, pos1)
-	local rules = mesecon.get_any_inputrules(node)
+end
+
+function mesecon:is_powered(pos, rule)
+	local node = minetest.get_node(pos)
+	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
+		for _, rule in ipairs(mesecon:flattenrules(rules)) do
-			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 = vector.add(pos, rname)
+				local np = mesecon:addPosRule(pos, rname)
-				local nn = mesecon.get_node_force(np)
+				local nn = minetest.get_node(np)
-
+				if (mesecon:is_conductor_on (nn, mesecon:invertRule(rname)) or mesecon:is_receptor_on (nn.name)) then
-				if (mesecon.is_conductor_on(nn, mesecon.invertRule(rname))
+					return true
-				or mesecon.is_receptor_on(nn.name)) then
-					table.insert(sourcepos, np)
 				end
 			end
 		end
 	else
-		local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
+		local rulenames = mesecon:rules_link_rule_all_inverted(pos, rule)
 		for _, rname in ipairs(rulenames) do
-			local np = vector.add(pos, rname)
+			local np = mesecon:addPosRule(pos, rname)
-			local nn = mesecon.get_node_force(np)
+			local nn = minetest.get_node(np)
-			if (mesecon.is_conductor_on (nn, mesecon.invertRule(rname))
+			if (mesecon:is_conductor_on (nn, mesecon:invertRule(rname)) or mesecon:is_receptor_on (nn.name)) then
-			or mesecon.is_receptor_on (nn.name)) then
+				return true
-				table.insert(sourcepos, np)
 			end
 		end
 	end
 	
-	-- Return FALSE if not powered, return list of sources if is powered
+	return false
-	if (#sourcepos == 0) then return false
+end
-	else return sourcepos end
+
+--Rules rotation Functions:
+function mesecon:rotate_rules_right(rules)
+	local nr = {}
+	for i, rule in ipairs(rules) do
+		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)
+	local nr = {}
+	for i, rule in ipairs(rules) do
+		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)
+	local nr = {}
+	for i, rule in ipairs(rules) do
+		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)
+	local nr = {}
+	for i, rule in ipairs(rules) do
+		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,14 +1,32 @@
--- Un-forceload any forceloaded mapblocks from older versions of Mesecons which
+minetest.swap_node = minetest.swap_node or function(pos, node)
--- used forceloading instead of VoxelManipulators.
+	local data = minetest.get_meta(pos):to_table()
-local BLOCKSIZE = 16
+	minetest.add_node(pos, node)
-
+	minetest.get_meta(pos):from_table(data)
--- convert block hash --> node position
-local function unhash_blockpos(hash)
-	return vector.multiply(minetest.get_position_from_hash(hash), BLOCKSIZE)
 end
 
-local old_forceloaded_blocks = mesecon.file2table("mesecon_forceloaded")
+local rules = {}
-for hash, _ in pairs(old_forceloaded_blocks) do
+rules.a = {x = -1, y = 0, z =  0, name="A"}
-	minetest.forceload_free_block(unhash_blockpos(hash))
+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
-os.remove(minetest.get_worldpath()..DIR_DELIM.."mesecon_forceloaded")

mesecons/mod.conf

@@ -1,2 +0,0 @@
-name = mesecons
-depends = default

mesecons/oldwires.lua

@@ -4,7 +4,7 @@ minetest.register_node("mesecons:mesecon_off", {
 	inventory_image = "jeija_mesecon_off.png",
 	wield_image = "jeija_mesecon_off.png",
 	paramtype = "light",
-	is_ground_content = false,
+	is_ground_content = true,
 	walkable = false,
 	selection_box = {
 		type = "fixed",
@@ -22,7 +22,7 @@ minetest.register_node("mesecons:mesecon_on", {
 	drawtype = "raillike",
 	tiles = {"jeija_mesecon_on.png", "jeija_mesecon_curved_on.png", "jeija_mesecon_t_junction_on.png", "jeija_mesecon_crossing_on.png"},
 	paramtype = "light",
-	is_ground_content = false,
+	is_ground_content = true,
 	walkable = false,
 	selection_box = {
 		type = "fixed",
@@ -30,7 +30,7 @@ minetest.register_node("mesecons:mesecon_on", {
 	},
 	groups = {dig_immediate=3, not_in_creaive_inventory=1, mesecon=1},
 	drop = "mesecons:mesecon_off 1",
-	light_source = minetest.LIGHT_MAX-11,
+	light_source = LIGHT_MAX-11,
 	mesecons = {conductor={
 		state = mesecon.state.on,
 		offstate = "mesecons:mesecon_off"

mesecons/presets.lua

@@ -1,8 +1,8 @@
 mesecon.rules = {}
 mesecon.state = {}
 
-mesecon.rules.default = {
+mesecon.rules.default =
-	{x =  0, y =  0, z = -1},
+{{x=0,  y=0,  z=-1},
  {x=1,  y=0,  z=0},
  {x=-1, y=0,  z=0},
  {x=0,  y=0,  z=1},
@@ -13,73 +13,32 @@ mesecon.rules.default = {
  {x=0,  y=1,  z=1},
  {x=0,  y=-1, z=1},
  {x=0,  y=1,  z=-1},
-	{x =  0, y = -1, z = -1},
+ {x=0,  y=-1, z=-1}}
-}
 
-mesecon.rules.floor = mesecon.mergetable(mesecon.rules.default, {{x = 0, y = -1, z = 0}})
+mesecon.rules.buttonlike =
-
+{{x = 1,  y = 0, z = 0},
-mesecon.rules.pplate = mesecon.mergetable(mesecon.rules.floor, {{x = 0, y = -2, z = 0}})
-
-mesecon.rules.buttonlike = {
-	{x = 1,  y =  0, z =  0},
  {x = 1,  y = 1, z = 0},
  {x = 1,  y =-1, z = 0},
  {x = 1,  y =-1, z = 1}, 
  {x = 1,  y =-1, z =-1},
-	{x = 2,  y =  0, z =  0},
+ {x = 2,  y = 0, z = 0}}
-}
 
-mesecon.rules.flat = {
+mesecon.rules.flat =
-	{x =  1, y = 0, z =  0},
+{{x = 1, y = 0, z = 0},
  {x =-1, y = 0, z = 0},
  {x = 0, y = 0, z = 1},
-	{x =  0, y = 0, z = -1},
+ {x = 0, y = 0, z =-1}}
-}
-
-mesecon.rules.alldirs = {
-	{x =  1, y =  0,  z =  0},
-	{x = -1, y =  0,  z =  0},
-	{x =  0, y =  1,  z =  0},
-	{x =  0, y = -1,  z =  0},
-	{x =  0, y =  0,  z =  1},
-	{x =  0, y =  0,  z = -1},
-}
-
-local rules_wallmounted = {
-	xp = mesecon.rotate_rules_down(mesecon.rules.floor),
-	xn = mesecon.rotate_rules_up(mesecon.rules.floor),
-	yp = mesecon.rotate_rules_up(mesecon.rotate_rules_up(mesecon.rules.floor)),
-	yn = mesecon.rules.floor,
-	zp = mesecon.rotate_rules_left(mesecon.rotate_rules_up(mesecon.rules.floor)),
-	zn = mesecon.rotate_rules_right(mesecon.rotate_rules_up(mesecon.rules.floor)),
-}
-
-local rules_buttonlike = {
-	xp = mesecon.rules.buttonlike,
-	xn = mesecon.rotate_rules_right(mesecon.rotate_rules_right(mesecon.rules.buttonlike)),
-	yp = mesecon.rotate_rules_down(mesecon.rules.buttonlike),
-	yn = mesecon.rotate_rules_up(mesecon.rules.buttonlike),
-	zp = mesecon.rotate_rules_right(mesecon.rules.buttonlike),
-	zn = mesecon.rotate_rules_left(mesecon.rules.buttonlike),
-}
-
-local function rules_from_dir(ruleset, dir)
-	if dir.x ==  1 then return ruleset.xp end
-	if dir.y ==  1 then return ruleset.yp end
-	if dir.z ==  1 then return ruleset.zp end
-	if dir.x == -1 then return ruleset.xn end
-	if dir.y == -1 then return ruleset.yn end
-	if dir.z == -1 then return ruleset.zn end
-end
-
-mesecon.rules.wallmounted_get = function(node)
-	local dir = minetest.wallmounted_to_dir(node.param2)
-	return rules_from_dir(rules_wallmounted, dir)
-end
  
 mesecon.rules.buttonlike_get = function(node)
-	local dir = minetest.facedir_to_dir(node.param2)
+	local rules = mesecon.rules.buttonlike
-	return rules_from_dir(rules_buttonlike, dir)
+	if node.param2 == 2 then
+		rules=mesecon:rotate_rules_left(rules)
+	elseif node.param2 == 3 then
+		rules=mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
+	elseif node.param2 == 0 then
+		rules=mesecon:rotate_rules_right(rules)
+	end
+	return rules
 end
 
 mesecon.state.on = "on"

mesecons/services.lua

@@ -1,136 +1,76 @@
 -- Dig and place services
 
 mesecon.on_placenode = function (pos, node)
-	mesecon.execute_autoconnect_hooks_now(pos, node)
-
 	-- Receptors: Send on signal when active
-	if mesecon.is_receptor_on(node.name) then
+	if mesecon:is_receptor_on(node.name) then
-		mesecon.receptor_on(pos, mesecon.receptor_get_rules(node))
+		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
+	if mesecon:is_conductor(node.name) then
-		local sources = mesecon.is_powered(pos)
+		if mesecon:is_powered(pos) then
-		if sources then
 			-- also call receptor_on if itself is powered already, so that neighboring
 			-- conductors will be activated (when pushing an on-conductor with a piston)
-			for _, s in ipairs(sources) do
+			mesecon:turnon (pos)
-				local rule = vector.subtract(pos, s)
+			mesecon:receptor_on (pos, mesecon:conductor_get_rules(node))
-				mesecon.turnon(pos, rule)
+		elseif mesecon:is_conductor_off(node.name) then
-			end
+			minetest.swap_node(pos, {name = mesecon:get_conductor_off(node)})
-			--mesecon.receptor_on (pos, mesecon.conductor_get_rules(node))
-		elseif mesecon.is_conductor_on(node) then
-			node.name = mesecon.get_conductor_off(node)
-			minetest.swap_node(pos, node)
 		end
 	end
 
 	-- Effectors: Send changesignal and activate or deactivate
-	if mesecon.is_effector(node.name) then
+	if mesecon:is_effector(node.name) then
-		local powered_rules = {}
+		if mesecon:is_powered(pos) then
-		local unpowered_rules = {}
+			mesecon:changesignal(pos, node, mesecon:effector_get_rules(node), "on", 1)
-
+			mesecon:activate(pos, node, nil, 1)
-		-- 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)
-			else table.insert(unpowered_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
 		else
-			for _, r in ipairs(unpowered_rules) do
+			mesecon:changesignal(pos, node, mesecon:effector_get_rules(node), "off", 1)
-				mesecon.deactivate(pos, node, r, 1)
+			mesecon:deactivate(pos, node, nil, 1)
-			end
 		end
 	end
 end
 
 mesecon.on_dignode = function (pos, node)
-	if mesecon.is_conductor_on(node) then
+	if mesecon:is_conductor_on(node) then
-		mesecon.receptor_off(pos, mesecon.conductor_get_rules(node))
+		mesecon:receptor_off(pos, mesecon:conductor_get_rules(node))
-	elseif mesecon.is_receptor_on(node.name) then
+	elseif mesecon:is_receptor_on(node.name) then
-		mesecon.receptor_off(pos, mesecon.receptor_get_rules(node))
+		mesecon:receptor_off(pos, mesecon:receptor_get_rules(node))
 	end
-
-	mesecon.execute_autoconnect_hooks_queue(pos, node)
-end
-
-function mesecon.on_blastnode(pos, intensity)
-	local node = minetest.get_node(pos)
-	minetest.remove_node(pos)
-	mesecon.on_dignode(pos, node)
-	return minetest.get_node_drops(node.name, "")
 end
 
 minetest.register_on_placenode(mesecon.on_placenode)
 minetest.register_on_dignode(mesecon.on_dignode)
 
 -- Overheating service for fast circuits
-local OVERHEAT_MAX = mesecon.setting("overheat_max", 20)
-local COOLDOWN_TIME = mesecon.setting("cooldown_time", 2.0)
-local COOLDOWN_STEP = mesecon.setting("cooldown_granularity", 0.5)
-local COOLDOWN_MULTIPLIER = OVERHEAT_MAX / COOLDOWN_TIME
-local cooldown_timer = 0.0
-local object_heat = {}
 
 -- returns true if heat is too high
-function mesecon.do_overheat(pos)
+mesecon.do_overheat = function(pos)
-	local id = minetest.hash_node_position(pos)
+	local meta = minetest.get_meta(pos)
-	local heat = (object_heat[id] or 0) + 1
+	local heat = meta:get_int("heat") or 0
-	object_heat[id] = heat
+
-	if heat >= OVERHEAT_MAX then
+	heat = heat + 1
-		minetest.log("action", "Node overheats at " .. minetest.pos_to_string(pos))
+	meta:set_int("heat", heat)
-		object_heat[id] = nil
+
+	if heat < OVERHEAT_MAX then
+		mesecon.queue:add_action(pos, "cooldown", {}, 1, nil, 0)
+	else
 		return true
 	end
+
 	return false
 end
 
-function mesecon.do_cooldown(pos)
+
-	local id = minetest.hash_node_position(pos)
+mesecon.queue:add_function("cooldown", function (pos)
-	object_heat[id] = nil
+	if minetest.get_item_group(minetest.get_node(pos).name, "overheat") == 0 then
+		return -- node has been moved, this one does not use overheating - ignore
 	end
 
-function mesecon.get_heat(pos)
+	local meta = minetest.get_meta(pos)
-	local id = minetest.hash_node_position(pos)
+	local heat = meta:get_int("heat")
-	return object_heat[id] or 0
-end
 
-function mesecon.move_hot_nodes(moved_nodes)
+	if (heat > 0) then
-	local new_heat = {}
+		meta:set_int("heat", heat - 1)
-	for _, n in ipairs(moved_nodes) do
-		local old_id = minetest.hash_node_position(n.oldpos)
-		local new_id = minetest.hash_node_position(n.pos)
-		new_heat[new_id] = object_heat[old_id]
-		object_heat[old_id] = nil
 	end
-	for id, heat in pairs(new_heat) do
+end)
-		object_heat[id] = heat
-	end
-end
-
-local function global_cooldown(dtime)
-	cooldown_timer = cooldown_timer + dtime
-	if cooldown_timer < COOLDOWN_STEP then
-		return -- don't overload the CPU
-	end
-	local cooldown = COOLDOWN_MULTIPLIER * cooldown_timer
-	cooldown_timer = 0
-	for id, heat in pairs(object_heat) do
-		heat = heat - cooldown
-		if heat <= 0 then
-			object_heat[id] = nil -- free some RAM
-		else
-			object_heat[id] = heat
-		end
-	end
-end
-minetest.register_globalstep(global_cooldown)

mesecons/settings.lua

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

mesecons/util.lua

@@ -1,62 +1,24 @@
-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)
-	minetest.set_node(newpos, node)
+	minetest.add_node(newpos, node)
 	minetest.get_meta(pos):from_table(meta)
 end
 
--- Rules rotation Functions:
+--[[ new functions:
-function mesecon.rotate_rules_right(rules)
+mesecon:flattenrules(allrules)
-	local nr = {}
+mesecon:rule2bit(findrule, allrules)
-	for i, rule in ipairs(rules) do
+mesecon:rule2meta(findrule, allrules)
-		table.insert(nr, {
+dec2bin(n)
-			x = -rule.z,
+mesecon:getstate(nodename, states)
-			y =  rule.y,
+mesecon:getbinstate(nodename, states)
-			z =  rule.x,
+mesecon:get_bit(binary, bit)
-			name = rule.name})
+mesecon:set_bit(binary, bit, value)
-	end
+mesecon:invertRule(r)
-	return nr
+--]]
-end
 
-function mesecon.rotate_rules_left(rules)
+function mesecon:flattenrules(allrules)
-	local nr = {}
-	for i, rule in ipairs(rules) do
-		table.insert(nr, {
-			x =  rule.z,
-			y =  rule.y,
-			z = -rule.x,
-			name = rule.name})
-	end
-	return nr
-end
-
-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})
-	end
-	return nr
-end
-
-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})
-	end
-	return nr
-end
---
-
-function mesecon.flattenrules(allrules)
 --[[
 	{
 		{
@@ -91,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
@@ -100,36 +62,35 @@ function mesecon.rule2bit(findrule, allrules)
 	end
 	for m,metarule in ipairs( allrules) do
 	for _,    rule in ipairs(metarule ) do
-		if vector.equals(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 vector.equals(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)
+function mesecon:rule2meta(findrule, allrules)
-	if #allrules == 0 then return {} end
+	local index = mesecon:rule2metaindex(findrule, allrules)
-
-	local index = mesecon.rule2metaindex(findrule, allrules)
 	if index == nil then
 		if allrules[1].x then
 			return allrules
@@ -140,16 +101,25 @@ function mesecon.rule2meta(findrule, allrules)
 	return allrules[index]
 end
 
-function mesecon.dec2bin(n)
+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 mesecon.dec2bin(x)..y
+			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
@@ -158,285 +128,68 @@ function mesecon.getstate(nodename, states)
 	error(nodename.." doesn't mention itself in "..dump(states))
 end
 
-function mesecon.getbinstate(nodename, states)
+function mesecon:getbinstate(nodename, states)
-	return mesecon.dec2bin(mesecon.getstate(nodename, states)-1)
+	return dec2bin(mesecon:getstate(nodename, states)-1)
 end
 
-function mesecon.get_bit(binary,bit)
+function mesecon:get_bit(binary,bit)
 	bit = bit or 1
 	local c = binary:len()-(bit-1)
 	return binary:sub(c,c) == "1"
 end
 
-function mesecon.set_bit(binary,bit,value)
+function mesecon:set_bit(binary,bit,value)
 	if value == "1" then
-		if not mesecon.get_bit(binary,bit) then
+		if not mesecon:get_bit(binary,bit) then
-			return mesecon.dec2bin(tonumber(binary,2)+math.pow(2,bit-1))
+			return dec2bin(tonumber(binary,2)+math.pow(2,bit-1))
 		end
 	elseif value == "0" then
-		if mesecon.get_bit(binary,bit) then
+		if mesecon:get_bit(binary,bit) then
-			return mesecon.dec2bin(tonumber(binary,2)-math.pow(2,bit-1))
+			return dec2bin(tonumber(binary,2)-math.pow(2,bit-1))
 		end
 	end
 	return binary
 	
 end
 
-function mesecon.invertRule(r)
+function mesecon:invertRule(r)
-	return vector.multiply(r, -1)
+	return {x = -r.x, y = -r.y, z = -r.z, sx = r.sx, sy = r.sy, sz = r.sz}
 end
 
-function mesecon.tablecopy(obj) -- deep copy
+function mesecon:addPosRule(p, r)
-	if type(obj) == "table" then
+	return {x = p.x + r.x, y = p.y + r.y, z = p.z + r.z}
-		return table.copy(obj)
-	end
-	return obj
 end
 
--- Returns whether two values are equal.
+function mesecon:cmpPos(p1, p2)
--- In tables, keys are compared for identity but values are compared recursively.
+	return (p1.x == p2.x and p1.y == p2.y and p1.z == p2.z)
--- There is no protection from infinite recursion.
+end
-function mesecon.cmpAny(t1, t2)
+
+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)
+		else
+			newtable[idx] = item
+		end
+	end
+
+	return newtable
+end
+
+function mesecon:cmpAny(t1, t2)
 	if type(t1) ~= type(t2) then return false end
-	if type(t1) ~= "table" then return t1 == t2 end
+	if type(t1) ~= "table" and type(t2) ~= "table" then return t1 == t2 end
 
-	-- Check that for each key of `t1` both tables have the same value
 	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
-
-	-- Check that all keys of `t2` are also keys of `t1` so were checked in the previous loop
-	for i, _ in pairs(t2) do
-		if t1[i] == nil 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.on_blast = spec_common.on_blast or mesecon.on_blastnode
-	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
-
--- File writing / reading utilities
-local wpath = minetest.get_worldpath()
-function mesecon.file2table(filename)
-	local f = io.open(wpath..DIR_DELIM..filename, "r")
-	if f == nil then return {} end
-	local t = f:read("*all")
-	f:close()
-	if t == "" or t == nil then return {} end
-	return minetest.deserialize(t)
-end
-
-function mesecon.table2file(filename, table)
-	local f = io.open(wpath..DIR_DELIM..filename, "w")
-	f:write(minetest.serialize(table))
-	f:close()
-end
-
--- Block position "hashing" (convert to integer) functions for voxelmanip cache
-local BLOCKSIZE = 16
-
--- convert node position --> block hash
-local function hash_blockpos(pos)
-	return minetest.hash_node_position({
-		x = math.floor(pos.x/BLOCKSIZE),
-		y = math.floor(pos.y/BLOCKSIZE),
-		z = math.floor(pos.z/BLOCKSIZE)
-	})
-end
-
--- Maps from a hashed mapblock position (as returned by hash_blockpos) to a
--- table.
---
--- Contents of the table are:
--- “vm” → the VoxelManipulator
--- “va” → the VoxelArea
--- “data” → the data array
--- “param1” → the param1 array
--- “param2” → the param2 array
--- “dirty” → true if data has been modified
---
--- Nil if no VM-based transaction is in progress.
-local vm_cache = nil
-
--- Starts a VoxelManipulator-based transaction.
---
--- During a VM transaction, calls to vm_get_node and vm_swap_node operate on a
--- cached copy of the world loaded via VoxelManipulators. That cache can later
--- be committed to the real map by means of vm_commit or discarded by means of
--- vm_abort.
-function mesecon.vm_begin()
-	vm_cache = {}
-end
-
--- Finishes a VoxelManipulator-based transaction, freeing the VMs and map data
--- and writing back any modified areas.
-function mesecon.vm_commit()
-	for hash, tbl in pairs(vm_cache) do
-		if tbl.dirty then
-			local vm = tbl.vm
-			vm:set_data(tbl.data)
-			vm:write_to_map()
-			vm:update_map()
-		end
-	end
-	vm_cache = nil
-end
-
--- Finishes a VoxelManipulator-based transaction, freeing the VMs and throwing
--- away any modified areas.
-function mesecon.vm_abort()
-	vm_cache = nil
-end
-
--- Gets the cache entry covering a position, populating it if necessary.
-local function vm_get_or_create_entry(pos)
-	local hash = hash_blockpos(pos)
-	local tbl = vm_cache[hash]
-	if not tbl then
-		local vm = minetest.get_voxel_manip(pos, pos)
-		local min_pos, max_pos = vm:get_emerged_area()
-		local va = VoxelArea:new{MinEdge = min_pos, MaxEdge = max_pos}
-		tbl = {vm = vm, va = va, data = vm:get_data(), param1 = vm:get_light_data(), param2 = vm:get_param2_data(), dirty = false}
-		vm_cache[hash] = tbl
-	end
-	return tbl
-end
-
--- Gets the node at a given position during a VoxelManipulator-based
--- transaction.
-function mesecon.vm_get_node(pos)
-	local tbl = vm_get_or_create_entry(pos)
-	local index = tbl.va:indexp(pos)
-	local node_value = tbl.data[index]
-	if node_value == core.CONTENT_IGNORE then
-		return nil
-	else
-		local node_param1 = tbl.param1[index]
-		local node_param2 = tbl.param2[index]
-		return {name = minetest.get_name_from_content_id(node_value), param1 = node_param1, param2 = node_param2}
-	end
-end
-
--- Sets a node’s name during a VoxelManipulator-based transaction.
---
--- Existing param1, param2, and metadata are left alone.
-function mesecon.vm_swap_node(pos, name)
-	local tbl = vm_get_or_create_entry(pos)
-	local index = tbl.va:indexp(pos)
-	tbl.data[index] = minetest.get_content_id(name)
-	tbl.dirty = true
-end
-
--- Gets the node at a given position, regardless of whether it is loaded or
--- not, respecting a transaction if one is in progress.
---
--- Outside a VM transaction, if the mapblock is not loaded, it is pulled into
--- the server’s main map data cache and then accessed from there.
---
--- Inside a VM transaction, the transaction’s VM cache is used.
-function mesecon.get_node_force(pos)
-	if vm_cache then
-		return mesecon.vm_get_node(pos)
-	else
-		local node = minetest.get_node_or_nil(pos)
-		if node == nil then
-			-- Node is not currently loaded; use a VoxelManipulator to prime
-			-- the mapblock cache and try again.
-			minetest.get_voxel_manip(pos, pos)
-			node = minetest.get_node_or_nil(pos)
-		end
-		return node
-	end
-end
-
--- Swaps the node at a given position, regardless of whether it is loaded or
--- not, respecting a transaction if one is in progress.
---
--- Outside a VM transaction, if the mapblock is not loaded, it is pulled into
--- the server’s main map data cache and then accessed from there.
---
--- Inside a VM transaction, the transaction’s VM cache is used.
---
--- This function can only be used to change the node’s name, not its parameters
--- or metadata.
-function mesecon.swap_node_force(pos, name)
-	if vm_cache then
-		return mesecon.vm_swap_node(pos, name)
-	else
-		-- This serves to both ensure the mapblock is loaded and also hand us
-		-- the old node table so we can preserve param2.
-		local node = mesecon.get_node_force(pos)
-		node.name = name
-		minetest.swap_node(pos, node)
-	end
-end
-
--- Autoconnect Hooks
--- Nodes like conductors may change their appearance and their connection rules
--- right after being placed or after being dug, e.g. the default wires use this
--- to automatically connect to linking nodes after placement.
--- After placement, the update function will be executed immediately so that the
--- possibly changed rules can be taken into account when recalculating the circuit.
--- After digging, the update function will be queued and executed after
--- recalculating the circuit. The update function must take care of updating the
--- node at the given position itself, but also all of the other nodes the given
--- position may have (had) a linking connection to.
-mesecon.autoconnect_hooks = {}
-
--- name: A unique name for the hook, e.g. "foowire". Used to name the actionqueue function.
--- fct: The update function with parameters function(pos, node)
-function mesecon.register_autoconnect_hook(name, fct)
-	mesecon.autoconnect_hooks[name] = fct
-	mesecon.queue:add_function("autoconnect_hook_"..name, fct)
-end
-
-function mesecon.execute_autoconnect_hooks_now(pos, node)
-	for _, fct in pairs(mesecon.autoconnect_hooks) do
-		fct(pos, node)
-	end
-end
-
-function mesecon.execute_autoconnect_hooks_queue(pos, node)
-	for name in pairs(mesecon.autoconnect_hooks) do
-		mesecon.queue:add_action(pos, "autoconnect_hook_"..name, {node})
-	end
-end

mesecons/wires.lua

@@ -0,0 +1,280 @@
+-- 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+
+
+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 }
+
+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}
+
+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}
+
+-- Registering the wires
+
+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 groups
+	local nodeid = 	tostring(xp )..tostring(zp )..tostring(xm )..tostring(zm )..
+			tostring(xpy)..tostring(zpy)..tostring(xmy)..tostring(zmy)
+
+	if nodeid == "00000000" then
+		groups = {dig_immediate = 3, mesecon_conductor_craftable=1}
+		wiredesc = "Mesecon"
+	else
+		groups = {dig_immediate = 3, not_in_creative_inventory = 1}
+		wiredesc = "Mesecons Wire (ID: "..nodeid..")"
+	end
+
+	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
+
+	if nodeid == "00000000" then
+		nodebox = {-8/16, -.5, -1/16, 8/16, -.5+1/16, 1/16}
+	end
+
+	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"
+		}}
+	})
+
+	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
+
+-- Updating the wires:
+-- Place the right connection wire
+
+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
+
+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 16",
+	recipe = "default:mese_crystal",
+})

mesecons_alias/depends.txt

@@ -0,0 +1 @@
+mesecons

mesecons_alias/mod.conf

@@ -1,2 +0,0 @@
-name = mesecons_alias
-depends = mesecons

mesecons_blinkyplant/depends.txt

@@ -0,0 +1 @@
+mesecons

mesecons_blinkyplant/doc/blinkyplant/description.html

@@ -1,2 +0,0 @@
-The blinky plants toggles between on and off state every three seconds. Can be used to make clocks. Also works after having restarted the game.
-It stops blinking in an inactive block, then starts again when the block becomes active.

mesecons_blinkyplant/init.lua

@@ -1,52 +1,102 @@
 -- The BLINKY_PLANT
-
+minetest.register_node("mesecons_blinkyplant: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",
 	drawtype = "plantlike",
+	visual_scale = 1,
+	tiles = {"jeija_blinky_plant_off.png"},
 	inventory_image = "jeija_blinky_plant_off.png",
-	paramtype = "light",
-	is_ground_content = false,
 	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,
+	mesecons = {receptor = {
-	on_rightclick = toggle_timer,
+		state = mesecon.state.off
-	on_construct = toggle_timer
+	}},
-},{
+	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},
+	inventory_image = "jeija_blinky_plant_off.png",
-	mesecons = {receptor = { state = mesecon.state.off }}
+	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},
+	inventory_image = "jeija_blinky_plant_off.png",
-	mesecons = {receptor = { state = mesecon.state.on }}
+	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",""},
+	recipe = {
 	{"","group:mesecon_conductor_craftable",""},
-			{"group:sapling","group:sapling","group:sapling"}}
+	{"","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_blinkyplant/mod.conf

@@ -1,2 +0,0 @@
-name = mesecons_blinkyplant
-depends = mesecons

mesecons_button/depends.txt

@@ -0,0 +1,2 @@
+mesecons
+mesecons_receiver

mesecons_button/doc/button/description.html

@@ -1 +0,0 @@
-This receptor can be attached to walls. It turns on for 1 second if it's punched.

mesecons_button/init.lua

@@ -4,13 +4,12 @@
 
 mesecon.button_turnoff = function (pos)
 	local node = minetest.get_node(pos)
-	if node.name ~= "mesecons_button:button_on" then -- has been dug
+	if node.name=="mesecons_button:button_on" then --has not been dug
-		return
-	end
 		minetest.swap_node(pos, {name = "mesecons_button:button_off", param2=node.param2})
-	minetest.sound_play("mesecons_button_pop", { pos = pos }, true)
+		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
 
 minetest.register_node("mesecons_button:button_off", {
@@ -25,10 +24,8 @@ minetest.register_node("mesecons_button:button_off", {
 	},
 	paramtype = "light",
 	paramtype2 = "facedir",
-	is_ground_content = false,
 	legacy_wallmounted = true,
 	walkable = false,
-	on_rotate = mesecon.buttonlike_onrotate,
 	sunlight_propagates = true,
 	selection_box = {
 	type = "fixed",
@@ -43,18 +40,17 @@ minetest.register_node("mesecons_button:button_off", {
 	},
 	groups = {dig_immediate=2, mesecon_needs_receiver = 1},
 	description = "Button",
-	on_rightclick = function (pos, node)
+	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 }, true)
+		minetest.sound_play("mesecons_button_push", {pos=pos})
-		minetest.get_node_timer(pos):start(1)
+		minetest.after(1, mesecon.button_turnoff, pos)
 	end,
 	sounds = default.node_sound_stone_defaults(),
 	mesecons = {receptor = {
 		state = mesecon.state.off,
 		rules = mesecon.rules.buttonlike_get
-	}},
+	}}
-	on_blast = mesecon.on_blastnode,
 })
 
 minetest.register_node("mesecons_button:button_on", {
@@ -69,11 +65,9 @@ minetest.register_node("mesecons_button:button_on", {
 		},
 	paramtype = "light",
 	paramtype2 = "facedir",
-	is_ground_content = false,
 	legacy_wallmounted = true,
 	walkable = false,
-	on_rotate = false,
+	light_source = LIGHT_MAX-7,
-	light_source = minetest.LIGHT_MAX-7,
 	sunlight_propagates = true,
 	selection_box = {
 		type = "fixed",
@@ -93,9 +87,7 @@ minetest.register_node("mesecons_button:button_on", {
 	mesecons = {receptor = {
 		state = mesecon.state.on,
 		rules = mesecon.rules.buttonlike_get
-	}},
+	}}
-	on_timer = mesecon.button_turnoff,
-	on_blast = mesecon.on_blastnode,
 })
 
 minetest.register_craft({

mesecons_button/mod.conf

@@ -1,2 +0,0 @@
-name = mesecons_button
-depends = mesecons, mesecons_receiver

mesecons_commandblock/depends.txt

@@ -0,0 +1 @@
+mesecons

mesecons_commandblock/doc/commandblock/description.html

@@ -1,2 +0,0 @@
-There is no crafting recipe as this should only be available for server admins. Quite similar to the Minecraft counterpart. Executes server commands.
-It works in inactive blocks.

mesecons_commandblock/init.lua

@@ -43,7 +43,7 @@ minetest.register_chatcommand("hp", {
 })
 
 local function initialize_data(meta)
-	local commands = minetest.formspec_escape(meta:get_string("commands"))
+	local commands = meta:get_string("commands")
 	meta:set_string("formspec",
 		"invsize[9,5;]" ..
 		"textarea[0.5,0.5;8.5,4;commands;Commands;"..commands.."]" ..
@@ -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)
@@ -93,24 +93,11 @@ local function receive_fields(pos, formname, fields, sender)
 end
 
 local function resolve_commands(commands, pos)
-	local players = minetest.get_connected_players()
-
-	-- No players online: remove all commands containing
-	-- @nearest, @farthest and @random
-	if #players == 0 then
-		commands = commands:gsub("[^\r\n]+", function (line)
-			if line:find("@nearest") then return "" end
-			if line:find("@farthest") then return "" end
-			if line:find("@random") then return "" end
-			return line
-		end)
-		return commands
-	end
-
 	local nearest, farthest = nil, nil
 	local min_distance, max_distance = math.huge, -1
+	local players = minetest.get_connected_players()
 	for index, player in pairs(players) do
-		local distance = vector.distance(pos, player:get_pos())
+		local distance = vector.distance(pos, player:getpos())
 		if distance < min_distance then
 			min_distance = distance
 			nearest = player:get_player_name()
@@ -174,15 +161,13 @@ end
 local function can_dig(pos, player)
 	local meta = minetest.get_meta(pos)
 	local owner = meta:get_string("owner")
-	return owner == "" or owner == player:get_player_name() or
+	return owner == "" or owner == player:get_player_name()
-		minetest.check_player_privs(player, "protection_bypass")
 end
 
 minetest.register_node("mesecons_commandblock:commandblock_off", {
 	description = "Command Block",
 	tiles = {"jeija_commandblock_off.png"},
 	inventory_image = minetest.inventorycube("jeija_commandblock_off.png"),
-	is_ground_content = false,
 	groups = {cracky=2, mesecon_effector_off=1},
 	on_construct = construct,
 	after_place_node = after_place,
@@ -191,13 +176,11 @@ minetest.register_node("mesecons_commandblock:commandblock_off", {
 	sounds = default.node_sound_stone_defaults(),
 	mesecons = {effector = {
 		action_on = commandblock_action_on
-	}},
+	}}
-	on_blast = mesecon.on_blastnode,
 })
 
 minetest.register_node("mesecons_commandblock:commandblock_on", {
 	tiles = {"jeija_commandblock_on.png"},
-	is_ground_content = false,
 	groups = {cracky=2, mesecon_effector_on=1, not_in_creative_inventory=1},
 	light_source = 10,
 	drop = "mesecons_commandblock:commandblock_off",
@@ -208,6 +191,5 @@ minetest.register_node("mesecons_commandblock:commandblock_on", {
 	sounds = default.node_sound_stone_defaults(),
 	mesecons = {effector = {
 		action_off = commandblock_action_off
-	}},
+	}}
-	on_blast = mesecon.on_blastnode,
 })

mesecons_commandblock/mod.conf

@@ -1,2 +0,0 @@
-name = mesecons_commandblock
-depends = mesecons

mesecons_delayer/depends.txt

@@ -0,0 +1 @@
+mesecons

mesecons_delayer/doc/delayer/description.html

@@ -1 +0,0 @@
-The delayer delays the signal from the input for a determined time. The time can be set by punching the delayer. Possible delays are: 0.1 seconds, 0.3 seconds, 0.5 seconds and 1 second. You may try to use it for creating songs with the noteblock. It works in unloaded blocks.

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
@@ -33,12 +33,21 @@ end
 
 -- Register the 2 (states) x 4 (delay times) delayers
 
-local delaytime = { 0.1, 0.3, 0.5, 1.0 }
-
 for i = 1, 4 do
+local groups = {}
+if i == 1 then 
+	groups = {bendy=2,snappy=1,dig_immediate=2}
+else
+	groups = {bendy=2,snappy=1,dig_immediate=2, not_in_creative_inventory=1}
+end
 
-local boxes = {
+local delaytime
-	 { -6/16, -8/16, -6/16, 6/16, -7/16, 6/16 },		-- the main slab
+if 		i == 1 then delaytime = 0.1
+elseif	i == 2 then delaytime = 0.3
+elseif	i == 3 then delaytime = 0.5
+elseif	i == 4 then delaytime = 1.0 end
+
+boxes = {{ -6/16, -8/16, -6/16, 6/16, -7/16, 6/16 },		-- the main slab
 
 	 { -2/16, -7/16, -4/16, 2/16, -26/64, -3/16 },		-- the jeweled "on" indicator
 	 { -3/16, -7/16, -3/16, 3/16, -26/64, -2/16 },
@@ -48,39 +57,11 @@ local boxes = {
 
 	 { -6/16, -7/16, -6/16, -4/16, -27/64, -4/16 },		-- the timer indicator
 	 { -8/16, -8/16, -1/16, -6/16, -7/16, 1/16 },		-- the two wire stubs
-	 { 6/16, -8/16, -1/16, 8/16, -7/16, 1/16 }
+	 { 6/16, -8/16, -1/16, 8/16, -7/16, 1/16 }}
-}
 
--- Delayer definition defaults
+minetest.register_node("mesecons_delayer:delayer_off_"..tostring(i), {
-local def = {
-	drawtype = "nodebox",
-	walkable = true,
-	selection_box = {
-		type = "fixed",
-		fixed = { -8/16, -8/16, -8/16, 8/16, -6/16, 8/16 },
-	},
-	node_box = {
-		type = "fixed",
-		fixed = boxes
-	},
-	paramtype = "light",
-	paramtype2 = "facedir",
-	sunlight_propagates = true,
-	is_ground_content = false,
-	delayer_time = delaytime[i],
-	sounds = default.node_sound_stone_defaults(),
-	on_blast = mesecon.on_blastnode,
-	drop = "mesecons_delayer:delayer_off_1",
-}
-
--- Deactivated delayer definition defaults
-local off_groups = {bendy=2,snappy=1,dig_immediate=2}
-if i > 1 then
-	off_groups.not_in_creative_inventory = 1
-end
-
-local off_state = {
 	description = "Delayer",
+	drawtype = "nodebox",
 	tiles = {
 		"mesecons_delayer_off_"..tostring(i)..".png",
 		"mesecons_delayer_bottom.png",
@@ -91,18 +72,35 @@ local off_state = {
 		},
 	inventory_image = "mesecons_delayer_off_1.png",
 	wield_image = "mesecons_delayer_off_1.png",
-	groups = off_groups,
+	walkable = true,
-	on_punch = function(pos, node, puncher)
+	selection_box = {
-		if minetest.is_protected(pos, puncher and puncher:get_player_name()) then
+		type = "fixed",
-			return
+		fixed = { -8/16, -8/16, -8/16, 8/16, -6/16, 8/16 },
+	},
+	node_box = {
+		type = "fixed",
+		fixed = boxes
+	},
+	groups = groups,
+	paramtype = "light",
+	paramtype2 = "facedir",
+	sunlight_propagates = true,
+	is_ground_content = true,
+	drop = 'mesecons_delayer:delayer_off_1',
+	on_punch = function (pos, node)
+		if node.name=="mesecons_delayer:delayer_off_1" then
+			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_off_2", param2=node.param2})
+		elseif node.name=="mesecons_delayer:delayer_off_2" then
+			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_off_3", param2=node.param2})
+		elseif node.name=="mesecons_delayer:delayer_off_3" then
+			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_off_4", param2=node.param2})
+		elseif node.name=="mesecons_delayer:delayer_off_4" then
+			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_off_1", param2=node.param2})
 		end
-
-		minetest.swap_node(pos, {
-			name = "mesecons_delayer:delayer_off_"..tostring(i % 4 + 1),
-			param2 = node.param2
-		})
 	end,
+	delayer_time = delaytime,
 	delayer_onstate = "mesecons_delayer:delayer_on_"..tostring(i),
+	sounds = default.node_sound_stone_defaults(),
 	mesecons = {
 		receptor =
 		{
@@ -114,16 +112,13 @@ local off_state = {
 			rules = delayer_get_input_rules,
 			action_on = delayer_activate
 		}
-	},
 	}
-for k, v in pairs(def) do
+})
-	off_state[k] = off_state[k] or v
-end
-minetest.register_node("mesecons_delayer:delayer_off_"..tostring(i), off_state)
 
--- Activated delayer definition defaults
+
-local on_state = {
+minetest.register_node("mesecons_delayer:delayer_on_"..tostring(i), {
 	description = "You hacker you",
+	drawtype = "nodebox",
 	tiles = {
 		"mesecons_delayer_on_"..tostring(i)..".png",
 		"mesecons_delayer_bottom.png",
@@ -132,17 +127,33 @@ local on_state = {
 		"mesecons_delayer_sides_on.png",
 		"mesecons_delayer_sides_on.png"
 		},
+	walkable = true,
+	selection_box = {
+		type = "fixed",
+		fixed = { -8/16, -8/16, -8/16, 8/16, -6/16, 8/16 },
+	},
+	node_box = {
+		type = "fixed",
+		fixed = boxes
+	},
 	groups = {bendy = 2, snappy = 1, dig_immediate = 2, not_in_creative_inventory = 1},
-	on_punch = function(pos, node, puncher)
+	paramtype = "light",
-		if minetest.is_protected(pos, puncher and puncher:get_player_name()) then
+	paramtype2 = "facedir",
-			return
+	sunlight_propagates = true,
+	is_ground_content = true,
+	drop = 'mesecons_delayer:delayer_off_1',
+	on_punch = function (pos, node)
+		if node.name=="mesecons_delayer:delayer_on_1" then
+			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_on_2", param2=node.param2})
+		elseif node.name=="mesecons_delayer:delayer_on_2" then
+			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_on_3", param2=node.param2})
+		elseif node.name=="mesecons_delayer:delayer_on_3" then
+			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_on_4", param2=node.param2})
+		elseif node.name=="mesecons_delayer:delayer_on_4" then
+			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_on_1", param2=node.param2})
 		end
-
-		minetest.swap_node(pos, {
-			name = "mesecons_delayer:delayer_on_"..tostring(i % 4 + 1),
-			param2 = node.param2
-		})
 	end,
+	delayer_time = delaytime,
 	delayer_offstate = "mesecons_delayer:delayer_off_"..tostring(i),
 	mesecons = {
 		receptor =
@@ -155,13 +166,8 @@ local on_state = {
 			rules = delayer_get_input_rules,
 			action_off = delayer_deactivate
 		}
-	},
 	}
-for k, v in pairs(def) do
+})
-	on_state[k] = on_state[k] or v
-end
-minetest.register_node("mesecons_delayer:delayer_on_"..tostring(i), on_state)
-
 end
 
 minetest.register_craft({

mesecons_delayer/mod.conf

@@ -1,2 +0,0 @@
-name = mesecons_delayer
-depends = mesecons