Document inactive block behaviour (#447)

Add check nil var with bug from crash server.
fixes #438

COPYING.txt

@@ -0,0 +1,30 @@
+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!
 
-[DOWNLOADS PAGE](http://mesecons.net/downloads.php)
+[DOWNLOAD IT NOW](https://github.com/minetest-mods/mesecons/archive/master.zip)
 
-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:
+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:
 
 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,13 +39,15 @@ 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.php) is your style?
+Or maybe a [comprehensive reference](http://mesecons.net/items.html) 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/Jeija/minetest-mod-mesecons)!
+Want to contribute to Mesecons itself? Check out the [source code](https://github.com/minetest-mods/mesecons)!
 
 Who wrote it anyways?
 ---------------------
@@ -53,6 +55,7 @@ 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

@@ -0,0 +1,12 @@
+{
+    "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

@@ -0,0 +1,64 @@
+{
+	"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

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

mesecons/actionqueue.lua

@@ -0,0 +1,105 @@
+mesecon.queue.actions={} -- contains all ActionQueue actions
+
+function mesecon.queue:add_function(name, func)
+	mesecon.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 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 = {	pos=mesecon.tablecopy(pos),
+				func=func,
+				params=mesecon.tablecopy(params or {}),
+				time=time,
+				owcheck=(overwritecheck and mesecon.tablecopy(overwritecheck)) or nil,
+				priority=priority}
+
+	local toremove = nil
+	-- Otherwise, add the action to the queue
+	if overwritecheck then -- check if old action has to be overwritten / removed:
+		for i, ac in ipairs(mesecon.queue.actions) do
+			if(vector.equals(pos, ac.pos)
+			and mesecon.cmpAny(overwritecheck, ac.owcheck)) then
+				toremove = i
+				break
+			end
+		end
+	end
+
+	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
+-- However, even that does not work in some cases, that's why we delay the time the globalsteps
+-- start to be execute by 5 seconds
+local get_highest_priority = function (actions)
+	local highestp = -1
+	local highesti
+	for i, ac in ipairs(actions) do
+		if ac.priority > highestp then
+			highestp = ac.priority
+			highesti = i
+		end
+	end
+
+	return highesti
+end
+
+local m_time = 0
+local resumetime = mesecon.setting("resumetime", 4)
+minetest.register_globalstep(function (dtime)
+	m_time = m_time + dtime
+	-- don't even try if server has not been running for XY seconds; resumetime = time to wait
+	-- after starting the server before processing the ActionQueue, don't set this too low
+	if (m_time < resumetime) then return end
+	local actions = mesecon.tablecopy(mesecon.queue.actions)
+	local actions_now={}
+
+	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
+			ac.time = ac.time - dtime -- executed later
+			table.insert(mesecon.queue.actions, ac)
+		else
+			table.insert(actions_now, ac)
+		end
+	end
+
+	while(#actions_now > 0) do -- execute highest priorities first, until all are executed
+		local hp = get_highest_priority(actions_now)
+		mesecon.queue:execute(actions_now[hp])
+		table.remove(actions_now, hp)
+	end
+end)
+
+function mesecon.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 mesecon.queue.funcs[action.func] then
+		mesecon.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
+mesecon.queue.actions = mesecon.file2table("mesecon_actionqueue")
+
+minetest.register_on_shutdown(function()
+	mesecon.table2file("mesecon_actionqueue", mesecon.queue.actions)
+end)

mesecons/init.lua

@@ -3,7 +3,7 @@
 -- |  \/  | |___ ____  |___ |      |    | | \  | |____
 -- |      | |        | |    |      |    | |  \ |     |
 -- |      | |___ ____| |___ |____  |____| |   \| ____|
--- by Jeija, Uberi (Temperest), sfan5, VanessaE
+-- by Jeija, Uberi (Temperest), sfan5, VanessaE, Hawk777 and contributors
 --
 --
 --
@@ -11,7 +11,7 @@
 -- See the documentation on the forum for additional information, especially about crafting
 --
 --
--- For developer documentation see the Developers' section on mesecons.TK
+-- For basic development resources, see http://mesecons.net/developers.html
 --
 --
 --
@@ -39,53 +39,26 @@
 --	}
 --}
 
-
 -- PUBLIC VARIABLES
 mesecon={} -- contains all functions and all global variables
-mesecon.actions_on={} -- Saves registered function callbacks for mesecon on | DEPRECATED
-mesecon.actions_off={} -- Saves registered function callbacks for mesecon off | DEPRECATED
-mesecon.actions_change={} -- Saves registered function callbacks for mesecon change | DEPRECATED
-mesecon.receptors={} --  saves all information about receptors  | DEPRECATED
-mesecon.effectors={} --  saves all information about effectors  | DEPRECATED
-mesecon.conductors={} -- saves all information about conductors | DEPRECATED
-
-
-local wpath = minetest.get_worldpath()
-local function read_file(fn)
-	local f = io.open(fn, "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 write_file(fn, tbl)
-	local f = io.open(fn, "w")
-	f:write(minetest.serialize(tbl))
-	f:close()
-end
-
-mesecon.to_update = read_file(wpath.."/mesecon_to_update")
-mesecon.r_to_update = read_file(wpath.."/mesecon_r_to_update")
-
-minetest.register_on_shutdown(function()
-	write_file(wpath.."/mesecon_to_update",mesecon.to_update)
-	write_file(wpath.."/mesecon_r_to_update",mesecon.r_to_update)
-end)
+mesecon.queue={} -- contains the ActionQueue
+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");
+
 -- Internal stuff
 -- This is the most important file
 -- it handles signal transmission and basically everything else
@@ -93,64 +66,63 @@ dofile(minetest.get_modpath("mesecons").."/util.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
 
-function mesecon:receptor_on_i(pos, rules)
+mesecon.queue:add_function("receptor_on", function (pos, rules)
+	mesecon.vm_begin()
+
 	rules = rules or mesecon.rules.default
 
-	for _, rule in ipairs(mesecon:flattenrules(rules)) do
-		local np = mesecon:addPosRule(pos, rule)
-		local rulenames = mesecon:rules_link_rule_all(pos, rule)
+	-- Call turnon on all linking positions
+	for _, rule in ipairs(mesecon.flattenrules(rules)) do
+		local np = vector.add(pos, rule)
+		local rulenames = mesecon.rules_link_rule_all(pos, rule)
 		for _, rulename in ipairs(rulenames) do
-			mesecon:turnon(np, rulename)
+			mesecon.turnon(np, rulename)
 		end
 	end
+
+	mesecon.vm_commit()
+end)
+
+function mesecon.receptor_on(pos, rules)
+	mesecon.queue:add_action(pos, "receptor_on", {rules}, nil, rules)
 end
 
-function mesecon:receptor_on(pos, rules)
-	if MESECONS_GLOBALSTEP then
+mesecon.queue:add_function("receptor_off", function (pos, rules)
 	rules = rules or mesecon.rules.default
-		mesecon.r_to_update[#mesecon.r_to_update+1]={pos=pos, rules=rules, action="on"}
-	else
-		mesecon:receptor_on_i(pos, rules)
-	end
-end
 
-function mesecon:receptor_off_i(pos, rules)
-	rules = rules or mesecon.rules.default
-	for _, rule in ipairs(mesecon:flattenrules(rules)) do
-		local np = mesecon:addPosRule(pos, rule)
-		local rulenames = mesecon:rules_link_rule_all(pos, rule)
+	-- Call turnoff on all linking positions
+	for _, rule in ipairs(mesecon.flattenrules(rules)) do
+		local np = vector.add(pos, rule)
+		local rulenames = mesecon.rules_link_rule_all(pos, rule)
 		for _, rulename in ipairs(rulenames) do
-			if not mesecon:connected_to_receptor(np, mesecon:invertRule(rule)) then
-				mesecon:turnoff(np, rulename)
-			else
-				mesecon:changesignal(np, minetest.get_node(np), rulename, mesecon.state.off)
-			end
-		end
-	end
-end
+			mesecon.vm_begin()
+			mesecon.changesignal(np, minetest.get_node(np), rulename, mesecon.state.off, 2)
 
-function mesecon:receptor_off(pos, rules)
-	if MESECONS_GLOBALSTEP then
-		rules = rules or mesecon.rules.default
-		mesecon.r_to_update[#mesecon.r_to_update+1]={pos=pos, rules=rules, action="off"}
+			-- Turnoff returns true if turnoff process was successful, no onstate receptor
+			-- was found along the way. Commit changes that were made in voxelmanip. If turnoff
+			-- returns true, an onstate receptor was found, abort voxelmanip transaction.
+			if (mesecon.turnoff(np, rulename)) then
+				mesecon.vm_commit()
 			else
-		mesecon:receptor_off_i(pos, rules)
+				mesecon.vm_abort()
 			end
+		end
+	end
+end)
+
+function mesecon.receptor_off(pos, rules)
+	mesecon.queue:add_action(pos, "receptor_off", {rules}, nil, rules)
 end
 
 
 print("[OK] Mesecons")
 
---The actual wires
-dofile(minetest.get_modpath("mesecons").."/wires.lua");
+-- Deprecated stuff
+-- To be removed in future releases
+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,62 +1,53 @@
 -- Internal.lua - The core of mesecons
 --
--- For more practical developer resources see mesecons.tk
+-- For more practical developer resources see http://mesecons.net/developers.php
 --
 -- Function overview
--- mesecon:get_effector(nodename)     --> Returns the mesecons.effector -specifictation in the nodedef by the nodename
--- mesecon:get_receptor(nodename)     --> Returns the mesecons.receptor -specifictation in the nodedef by the nodename
--- mesecon:get_conductor(nodename)    --> Returns the mesecons.conductor-specifictation in the nodedef by the nodename
--- mesecon:get_any_inputrules (node)  --> Returns the rules of a node if it is a conductor or an effector
--- mesecon:get_any_outputrules (node) --> Returns the rules of a node if it is a conductor or a receptor
+-- mesecon.get_effector(nodename)	--> Returns the mesecons.effector -specifictation in the nodedef by the nodename
+-- mesecon.get_receptor(nodename)	--> Returns the mesecons.receptor -specifictation in the nodedef by the nodename
+-- mesecon.get_conductor(nodename)	--> Returns the mesecons.conductor-specifictation in the nodedef by the nodename
+-- mesecon.get_any_inputrules (node)	--> Returns the rules of a node if it is a conductor or an effector
+-- mesecon.get_any_outputrules (node)	--> Returns the rules of a node if it is a conductor or a receptor
 
 -- RECEPTORS
--- mesecon:is_receptor(nodename)     --> Returns true if nodename is a receptor
--- mesecon:is_receptor_on(nodename)  --> Returns true if nodename is an receptor with state = mesecon.state.on
--- mesecon:is_receptor_off(nodename) --> Returns true if nodename is an receptor with state = mesecon.state.off
--- mesecon:receptor_get_rules(node)  --> Returns the rules of the receptor (mesecon.rules.default if none specified)
+-- mesecon.is_receptor(nodename)	--> Returns true if nodename is a receptor
+-- mesecon.is_receptor_on(nodename	--> Returns true if nodename is an receptor with state = mesecon.state.on
+-- mesecon.is_receptor_off(nodename)	--> Returns true if nodename is an receptor with state = mesecon.state.off
+-- mesecon.receptor_get_rules(node)	--> Returns the rules of the receptor (mesecon.rules.default if none specified)
 
 -- EFFECTORS
--- mesecon:is_effector(nodename)     --> Returns true if nodename is an effector
--- mesecon:is_effector_on(nodename)  --> Returns true if nodename is an effector with nodedef.mesecons.effector.action_off
--- mesecon:is_effector_off(nodename) --> Returns true if nodename is an effector with nodedef.mesecons.effector.action_on
--- mesecon:effector_get_rules(node)  --> Returns the input rules of the effector (mesecon.rules.default if none specified)
+-- mesecon.is_effector(nodename)	--> Returns true if nodename is an effector
+-- mesecon.is_effector_on(nodename)	--> Returns true if nodename is an effector with nodedef.mesecons.effector.action_off
+-- mesecon.is_effector_off(nodename)	--> Returns true if nodename is an effector with nodedef.mesecons.effector.action_on
+-- mesecon.effector_get_rules(node)	--> Returns the input rules of the effector (mesecon.rules.default if none specified)
 
 -- SIGNALS
--- mesecon:activate(pos, node)     --> Activates   the effector node at the specific pos (calls nodedef.mesecons.effector.action_on)
--- mesecon:deactivate(pos, node)   --> Deactivates the effector node at the specific pos (calls nodedef.mesecons.effector.action_off)
--- mesecon:changesignal(pos, node, rulename, newstate) --> Changes     the effector node at the specific pos (calls nodedef.mesecons.effector.action_change)
-
--- RULES
--- mesecon:add_rules(name, rules) | deprecated? --> Saves rules table by name
--- mesecon:get_rules(name, rules) | deprecated? --> Loads rules table with name
+-- mesecon.activate(pos, node, depth)				--> Activates   the effector node at the specific pos (calls nodedef.mesecons.effector.action_on), higher depths are executed later
+-- mesecon.deactivate(pos, node, depth)				--> Deactivates the effector node at the specific pos (calls nodedef.mesecons.effector.action_off), higher depths are executed later
+-- mesecon.changesignal(pos, node, rulename, newstate, depth)	--> Changes     the effector node at the specific pos (calls nodedef.mesecons.effector.action_change), higher depths are executed later
 
 -- CONDUCTORS
--- mesecon:is_conductor(nodename)     --> Returns true if nodename is a conductor
--- mesecon:is_conductor_on(node)  --> Returns true if node is a conductor with state = mesecon.state.on
--- mesecon:is_conductor_off(node) --> Returns true if node is a conductor with state = mesecon.state.off
--- mesecon:get_conductor_on(node_off) --> Returns the onstate  nodename of the conductor
--- mesecon:get_conductor_off(node_on) --> Returns the offstate nodename of the conductor
--- mesecon:conductor_get_rules(node)  --> Returns the input+output rules of a conductor (mesecon.rules.default if none specified)
+-- mesecon.is_conductor(nodename)	--> Returns true if nodename is a conductor
+-- mesecon.is_conductor_on(node		--> Returns true if node is a conductor with state = mesecon.state.on
+-- mesecon.is_conductor_off(node)	--> Returns true if node is a conductor with state = mesecon.state.off
+-- mesecon.get_conductor_on(node_off)	--> Returns the onstate  nodename of the conductor
+-- mesecon.get_conductor_off(node_on)	--> Returns the offstate nodename of the conductor
+-- mesecon.conductor_get_rules(node)	--> Returns the input+output rules of a conductor (mesecon.rules.default if none specified)
 
 -- HIGH-LEVEL Internals
--- mesecon:is_power_on(pos)             --> Returns true if pos emits power in any way
--- mesecon:is_power_off(pos)            --> Returns true if pos does not emit power in any way
--- mesecon:turnon(pos, rulename)        --> Returns true  whatever there is at pos. Calls itself for connected nodes (if pos is a conductor) --> recursive, the rulename is the name of the input rule that caused calling turnon
--- 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
--- mesecon:connected_to_receptor(pos)   --> Returns true if pos is connected to a receptor directly or via conductors; calls itself if pos is a conductor --> recursive
--- mesecon:rules_link(output, input, dug_outputrules) --> Returns true if outputposition + outputrules = inputposition and inputposition + inputrules = outputposition (if the two positions connect)
--- mesecon:rules_link_anydir(outp., inp., d_outpr.)   --> Same as rules mesecon:rules_link but also returns true if output and input are swapped
--- mesecon:is_powered(pos)              --> Returns true if pos is powered by a receptor or a conductor
+-- mesecon.is_power_on(pos)				--> Returns true if pos emits power in any way
+-- mesecon.is_power_off(pos)				--> Returns true if pos does not emit power in any way
+-- mesecon.is_powered(pos)				--> Returns true if pos is powered by a receptor or a conductor
 
--- RULES ROTATION helpsers
--- mesecon:rotate_rules_right(rules)
--- mesecon:rotate_rules_left(rules)
--- mesecon:rotate_rules_up(rules)
--- mesecon:rotate_rules_down(rules)
+-- RULES ROTATION helpers
+-- mesecon.rotate_rules_right(rules)
+-- mesecon.rotate_rules_left(rules)
+-- mesecon.rotate_rules_up(rules)
+-- mesecon.rotate_rules_down(rules)
 -- These functions return rules that have been rotated in the specific direction
 
 -- General
-function mesecon:get_effector(nodename)
+function mesecon.get_effector(nodename)
 	if  minetest.registered_nodes[nodename]
 	and minetest.registered_nodes[nodename].mesecons
 	and minetest.registered_nodes[nodename].mesecons.effector then
@@ -64,7 +55,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
@@ -72,7 +63,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
@@ -80,52 +71,59 @@ function mesecon:get_conductor(nodename)
 	end
 end
 
-function mesecon:get_any_outputrules (node)
-	if mesecon:is_conductor(node.name) then
-		return mesecon:conductor_get_rules(node)
-	elseif mesecon:is_receptor(node.name) then
-		return mesecon:receptor_get_rules(node)
+function mesecon.get_any_outputrules(node)
+	if not node then return nil end
+
+	if mesecon.is_conductor(node.name) then
+		return mesecon.conductor_get_rules(node)
+	elseif mesecon.is_receptor(node.name) then
+		return mesecon.receptor_get_rules(node)
 	end
-	return false
 end
 
-function mesecon:get_any_inputrules (node)
-	if mesecon:is_conductor(node.name) then
-		return mesecon:conductor_get_rules(node)
-	elseif mesecon:is_effector(node.name) then
-		return mesecon:effector_get_rules(node)
+function mesecon.get_any_inputrules(node)
+	if not node then return nil end
+
+	if mesecon.is_conductor(node.name) then
+		return mesecon.conductor_get_rules(node)
+	elseif mesecon.is_effector(node.name) then
+		return mesecon.effector_get_rules(node)
 	end
-	return false
+end
+
+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)
-	local receptor = mesecon:get_receptor(nodename)
+function mesecon.is_receptor_on(nodename)
+	local receptor = mesecon.get_receptor(nodename)
 	if receptor and receptor.state == mesecon.state.on then
 		return true
 	end
 	return false
 end
 
-function mesecon:is_receptor_off(nodename)
-	local receptor = mesecon:get_receptor(nodename)
+function mesecon.is_receptor_off(nodename)
+	local receptor = mesecon.get_receptor(nodename)
 	if receptor and receptor.state == mesecon.state.off then
 		return true
 	end
 	return false
 end
 
-function mesecon:is_receptor(nodename)
-	local receptor = mesecon:get_receptor(nodename)
+function mesecon.is_receptor(nodename)
+	local receptor = mesecon.get_receptor(nodename)
 	if receptor then
 		return true
 	end
 	return false
 end
 
-function mesecon:receptor_get_rules(node)
-	local receptor = mesecon:get_receptor(node.name)
+function mesecon.receptor_get_rules(node)
+	local receptor = mesecon.get_receptor(node.name)
 	if receptor then
 		local rules = receptor.rules
 		if type(rules) == 'function' then
@@ -140,32 +138,32 @@ end
 
 -- Effectors
 -- Nodes that can be powered by mesecons
-function mesecon:is_effector_on(nodename)
-	local effector = mesecon:get_effector(nodename)
+function mesecon.is_effector_on(nodename)
+	local effector = mesecon.get_effector(nodename)
 	if effector and effector.action_off then
 		return true
 	end
 	return false
 end
 
-function mesecon:is_effector_off(nodename)
-	local effector = mesecon:get_effector(nodename)
+function mesecon.is_effector_off(nodename)
+	local effector = mesecon.get_effector(nodename)
 	if effector and effector.action_on then
 		return true
 	end
 	return false
 end
 
-function mesecon:is_effector(nodename)
-	local effector = mesecon:get_effector(nodename)
+function mesecon.is_effector(nodename)
+	local effector = mesecon.get_effector(nodename)
 	if effector then
 		return true
 	end
 	return false
 end
 
-function mesecon:effector_get_rules(node)
-	local effector = mesecon:get_effector(node.name)
+function mesecon.effector_get_rules(node)
+	local effector = mesecon.get_effector(node.name)
 	if effector then
 		local rules = effector.rules
 		if type(rules) == 'function' then
@@ -177,205 +175,168 @@ function mesecon:effector_get_rules(node)
 	return mesecon.rules.default
 end
 
---Signals
+-- #######################
+-- # Signals (effectors) #
+-- #######################
+
+-- Activation:
+mesecon.queue:add_function("activate", function (pos, rulename)
+	local node = mesecon.get_node_force(pos)
+	if not node then return end
+
+	local effector = mesecon.get_effector(node.name)
 
-function mesecon:activate(pos, node, rulename)
-	if MESECONS_GLOBALSTEP then
-		if rulename == nil then
-			for _,rule in ipairs(mesecon:effector_get_rules(node)) do
-				mesecon:activate(pos, node, rule)
-			end
-			return
-		end
-		add_action(pos, "on", rulename)
-	else
-		local effector = mesecon:get_effector(node.name)
 	if effector and effector.action_on then
-			effector.action_on (pos, node, rulename)
+		effector.action_on(pos, node, rulename)
 	end
-	end
-end
+end)
 
-function mesecon:deactivate(pos, node, rulename)
-	if MESECONS_GLOBALSTEP then
+function mesecon.activate(pos, node, rulename, depth)
 	if rulename == nil then
-			for _,rule in ipairs(mesecon:effector_get_rules(node)) do
-				mesecon:deactivate(pos, node, rule)
+		for _,rule in ipairs(mesecon.effector_get_rules(node)) do
+			mesecon.activate(pos, node, rule, depth + 1)
 		end
 		return
 	end
-		add_action(pos, "off", rulename)
-	else
-		local effector = mesecon:get_effector(node.name)
-		if effector and effector.action_off then
-			effector.action_off (pos, node, rulename)
-		end
-	end
+	mesecon.queue:add_action(pos, "activate", {rulename}, nil, rulename, 1 / depth)
 end
 
-function mesecon:changesignal(pos, node, rulename, newstate)
 
-	newstate = newstate or "on"
-	--rulename = rulename or mesecon.rules.default
-	if MESECONS_GLOBALSTEP then
+-- Deactivation
+mesecon.queue:add_function("deactivate", function (pos, rulename)
+	local node = mesecon.get_node_force(pos)
+	if not node then return end
+
+	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)
 	if rulename == nil then
-			for _,rule in ipairs(mesecon:effector_get_rules(node)) do
-				mesecon:changesignal(pos, node, rule, newstate)
+		for _,rule in ipairs(mesecon.effector_get_rules(node)) do
+			mesecon.deactivate(pos, node, rule, depth + 1)
 		end
 		return
 	end
-		add_action(pos, "c"..newstate, rulename)
-	else
-		local effector = mesecon:get_effector(node.name)
+	mesecon.queue:add_action(pos, "deactivate", {rulename}, nil, rulename, 1 / depth)
+end
+
+
+-- Change
+mesecon.queue:add_function("change", function (pos, rulename, changetype)
+	local node = mesecon.get_node_force(pos)
+	if not node then return end
+
+	local effector = mesecon.get_effector(node.name)
+
 	if effector and effector.action_change then
-			effector.action_change (pos, node, rulename, newstate)
+		effector.action_change(pos, node, rulename, changetype)
 	end
-	end
-end
+end)
 
-function execute_actions(dtime)
-	local nactions = mesecon.to_update
-	mesecon.to_update = {}
-	for _,i in ipairs(nactions) do
-		node = minetest.get_node(i.pos)
-		if node.name=="ignore" then
-			add_action(i.pos, i.action, i.rname)
-		else
-			effector = mesecon:get_effector(node.name)
-			if i.action == "on" then
-				if effector and effector.action_on then
-					effector.action_on(i.pos, node, i.rname)
-				end
-			elseif i.action == "off" then
-				if effector and effector.action_off then
-					effector.action_off(i.pos, node, i.rname)
-				end
-			elseif i.action == "con" then
-				if effector and effector.action_change then
-					effector.action_change(i.pos, node, i.rname, "on")
-				end
-			elseif i.action == "coff" then
-				if effector and effector.action_change then
-					effector.action_change(i.pos, node, i.rname, "off")
-				end
-			end
-		end
-	end
-	local nactions = mesecon.r_to_update
-	mesecon.r_to_update = {}
-	for _,i in ipairs(nactions) do
-		if i.action == "on" then
-			mesecon:receptor_on_i(i.pos, i.rules)
-		else
-			mesecon:receptor_off_i(i.pos,i.rules)
-		end
-	end
-end
-
-minetest.register_globalstep(execute_actions)
-
-function add_action(pos, action, rname)
-	for i, update in ipairs(mesecon.to_update) do
-		-- check if action for this node already exist, if so correct it:
-		if mesecon:cmpPos(pos, update.pos) and mesecon:cmpPos(update.rname, rname) then
-			mesecon.to_update[i].action = action
-			return -- action added (as correction), so return now
+function mesecon.changesignal(pos, node, rulename, newstate, depth)
+	if rulename == nil then
+		for _,rule in ipairs(mesecon.effector_get_rules(node)) do
+			mesecon.changesignal(pos, node, rule, newstate, depth + 1)
 		end
+		return
 	end
 
-	table.insert(mesecon.to_update, {pos = pos, action = action, rname = rname})
-end
-
---Rules
-
-function mesecon:add_rules(name, rules)
-	mesecon.rules[name] = rules
-end
-
-function mesecon:get_rules(name)
-	return mesecon.rules[name]
+	-- Include "change" in overwritecheck so that it cannot be overwritten
+	-- by "active" / "deactivate" that will be called upon the node at the same time.
+	local overwritecheck = {"change", rulename}
+	mesecon.queue:add_action(pos, "change", {rulename, newstate}, nil, overwritecheck, 1 / depth)
 end
 
 -- Conductors
 
-function mesecon:is_conductor_on(node, rulename)
-	local conductor = mesecon:get_conductor(node.name)
+function mesecon.is_conductor_on(node, rulename)
+	if not node then return false end
+
+	local conductor = mesecon.get_conductor(node.name)
 	if conductor then
 		if conductor.state then
 			return conductor.state == mesecon.state.on
 		end
 		if conductor.states then
 			if not rulename then
-				return mesecon:getstate(node.name, conductor.states) ~= 1
+				return mesecon.getstate(node.name, conductor.states) ~= 1
 			end
-			local bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node))
-			local binstate = mesecon:getbinstate(node.name, conductor.states)
-			return mesecon:get_bit(binstate, bit)
+			local bit = mesecon.rule2bit(rulename, mesecon.conductor_get_rules(node))
+			local binstate = mesecon.getbinstate(node.name, conductor.states)
+			return mesecon.get_bit(binstate, bit)
 		end
 	end
+
 	return false
 end
 
-function mesecon:is_conductor_off(node, rulename)
-	local conductor = mesecon:get_conductor(node.name)
+function mesecon.is_conductor_off(node, rulename)
+	if not node then return false end
+
+	local conductor = mesecon.get_conductor(node.name)
 	if conductor then
 		if conductor.state then
 			return conductor.state == mesecon.state.off
 		end
 		if conductor.states then
 			if not rulename then
-				return mesecon:getstate(node.name, conductor.states) == 1
+				return mesecon.getstate(node.name, conductor.states) == 1
 			end
-			local bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node))
-			local binstate = mesecon:getbinstate(node.name, conductor.states)
-			return not mesecon:get_bit(binstate, bit)
+			local bit = mesecon.rule2bit(rulename, mesecon.conductor_get_rules(node))
+			local binstate = mesecon.getbinstate(node.name, conductor.states)
+			return not mesecon.get_bit(binstate, bit)
 		end
 	end
+
 	return false
 end
 
-function mesecon:is_conductor(nodename)
-	local conductor = mesecon:get_conductor(nodename)
+function mesecon.is_conductor(nodename)
+	local conductor = mesecon.get_conductor(nodename)
 	if conductor then
 		return true
 	end
 	return false
 end
 
-function mesecon:get_conductor_on(node_off, rulename)
-	local conductor = mesecon:get_conductor(node_off.name)
+function mesecon.get_conductor_on(node_off, rulename)
+	local conductor = mesecon.get_conductor(node_off.name)
 	if conductor then
 		if conductor.onstate then
 			return conductor.onstate
 		end
 		if conductor.states then
-			local bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node_off))
-			local binstate = mesecon:getbinstate(node_off.name, conductor.states)
-			binstate = mesecon:set_bit(binstate, bit, "1")
+			local bit = mesecon.rule2bit(rulename, mesecon.conductor_get_rules(node_off))
+			local binstate = mesecon.getbinstate(node_off.name, conductor.states)
+			binstate = mesecon.set_bit(binstate, bit, "1")
 			return conductor.states[tonumber(binstate,2)+1]
 		end
 	end
 	return offstate
 end
 
-function mesecon:get_conductor_off(node_on, rulename)
-	local conductor = mesecon:get_conductor(node_on.name)
+function mesecon.get_conductor_off(node_on, rulename)
+	local conductor = mesecon.get_conductor(node_on.name)
 	if conductor then
 		if conductor.offstate then
 			return conductor.offstate
 		end
 		if conductor.states then
-			local bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node_on))
-			local binstate = mesecon:getbinstate(node_on.name, conductor.states)
-			binstate = mesecon:set_bit(binstate, bit, "0")
+			local bit = mesecon.rule2bit(rulename, mesecon.conductor_get_rules(node_on))
+			local binstate = mesecon.getbinstate(node_on.name, conductor.states)
+			binstate = mesecon.set_bit(binstate, bit, "0")
 			return conductor.states[tonumber(binstate,2)+1]
 		end
 	end
 	return onstate
 end
 
-function mesecon:conductor_get_rules(node)
-	local conductor = mesecon:get_conductor(node.name)
+function mesecon.conductor_get_rules(node)
+	local conductor = mesecon.get_conductor(node.name)
 	if conductor then
 		local rules = conductor.rules
 		if type(rules) == 'function' then
@@ -389,308 +350,201 @@ end
 
 -- some more general high-level stuff
 
-function mesecon:is_power_on(pos, rulename)
-	local node = minetest.get_node(pos)
-	if mesecon:is_conductor_on(node, rulename) or mesecon:is_receptor_on(node.name) then
+function mesecon.is_power_on(pos, rulename)
+	local node = mesecon.get_node_force(pos)
+	if node and (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)
-	local node = minetest.get_node(pos)
-	if mesecon:is_conductor_off(node, rulename) or mesecon:is_receptor_off(node.name) then
+function mesecon.is_power_off(pos, rulename)
+	local node = mesecon.get_node_force(pos)
+	if node and (mesecon.is_conductor_off(node, rulename) or mesecon.is_receptor_off(node.name)) then
 		return true
 	end
 	return false
 end
 
-function mesecon:turnon(pos, rulename)
-	local node = minetest.get_node(pos)
+-- Turn off an equipotential section starting at `pos`, which outputs in the direction of `link`.
+-- Breadth-first search. Map is abstracted away in a voxelmanip.
+-- Follow all all conductor paths replacing conductors that were already
+-- looked at, activating / changing all effectors along the way.
+function mesecon.turnon(pos, link)
+	local frontiers = {{pos = pos, link = link}}
 
-	if mesecon:is_conductor_off(node, rulename) then
-		local rules = mesecon:conductor_get_rules(node)
+	local depth = 1
+	while frontiers[1] do
+		local f = table.remove(frontiers, 1)
+		local node = mesecon.get_node_force(f.pos)
 
-		if not rulename then
-			for _, rule in ipairs(mesecon:flattenrules(rules)) do
-				if mesecon:connected_to_receptor(pos, rule) then
-					mesecon:turnon(pos, rule)
+		if not node then
+			-- Area does not exist; do nothing
+		elseif mesecon.is_conductor_off(node, f.link) then
+			local rules = mesecon.conductor_get_rules(node)
+
+			-- Call turnon on neighbors
+			for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
+				local np = vector.add(f.pos, r)
+				for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
+					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)
-			local rulenames = mesecon:rules_link_rule_all(pos, rule)
-
-			for _, rulename in ipairs(rulenames) do
-				mesecon:turnon(np, rulename)
+			mesecon.swap_node_force(f.pos, mesecon.get_conductor_on(node, f.link))
+		elseif mesecon.is_effector(node.name) then
+			mesecon.changesignal(f.pos, node, f.link, mesecon.state.on, depth)
+			if mesecon.is_effector_off(node.name) then
+				mesecon.activate(f.pos, node, f.link, depth)
 			end
 		end
-	elseif mesecon:is_effector(node.name) then
-		mesecon:changesignal(pos, node, rulename, mesecon.state.on)
-		if mesecon:is_effector_off(node.name) then
-			mesecon:activate(pos, node, rulename)
-		end
+		depth = depth + 1
 	end
 end
 
-function mesecon:turnoff(pos, rulename)
-	local node = minetest.get_node(pos)
+-- Turn on an equipotential section starting at `pos`, which outputs in the direction of `link`.
+-- Breadth-first search. Map is abstracted away in a voxelmanip.
+-- Follow all all conductor paths replacing conductors that were already
+-- 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 = {}
 
-	if mesecon:is_conductor_on(node, rulename) then
-		local rules = mesecon:conductor_get_rules(node)
-		--[[
-		if not rulename then
-			for _, rule in ipairs(mesecon:flattenrules(rules)) do
-				if mesecon:is_powered(pos, rule) then
-					mesecon:turnoff(pos, rule)
-				end
-			end
-			return
-		end
-		--]]
-		minetest.swap_node(pos, {name = mesecon:get_conductor_off(node, rulename), param2 = node.param2})
+	local depth = 1
+	while frontiers[1] do
+		local f = table.remove(frontiers, 1)
+		local node = mesecon.get_node_force(f.pos)
 
-		for _, rule in ipairs(mesecon:rule2meta(rulename, rules)) do
-			local np = mesecon:addPosRule(pos, rule)
-			local rulenames = mesecon:rules_link_rule_all(pos, rule)
-
-			for _, rulename in ipairs(rulenames) do
-				mesecon:turnoff(np, rulename)
-			end
-		end
-	elseif mesecon:is_effector(node.name) then
-		mesecon:changesignal(pos, node, rulename, mesecon.state.off)
-		if mesecon:is_effector_on(node.name)
-		and not mesecon:is_powered(pos) then
-			mesecon:deactivate(pos, node, rulename)
-		end
-	end
-end
-
-
-function mesecon:connected_to_receptor(pos, rulename)
-	local node = minetest.get_node(pos)
-
-	-- Check if conductors around are connected
-	local rules = mesecon:get_any_inputrules(node)
-	if not rules then return false end
-
-	for _, rule in ipairs(mesecon:rule2meta(rulename, rules)) do
-		local np = mesecon:addPosRule(pos, rule)
-		if mesecon:rules_link(np, pos) then
-			if mesecon:find_receptor_on(np, {}, mesecon:invertRule(rule)) then
-				return true
-			end
-		end
-	end
+		if not node then
+			-- Area does not exist; do nothing
+		elseif mesecon.is_conductor_on(node, f.link) then
+			local rules = mesecon.conductor_get_rules(node)
+			for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
+				local np = vector.add(f.pos, r)
 
+				-- 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
+				end
 
-function mesecon:find_receptor_on(pos, checked, rulename)
-	local node = minetest.get_node(pos)
+				-- Call turnoff on neighbors
+				for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
+					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
-
-	if mesecon:is_conductor(node.name) then
-		local rules = mesecon:conductor_get_rules(node)
-		local metaindex = mesecon:rule2metaindex(rulename, rules)
-		-- find out if node has already been checked (to prevent from endless loop)
-		for _, cp in ipairs(checked) do
-			if mesecon:cmpPos(cp, pos) and cp.metaindex == metaindex then
-				return false, checked
-			end
-		end
-		-- add current position to checked
-		table.insert(checked, {x=pos.x, y=pos.y, z=pos.z, metaindex = metaindex})
-		for _, rule in ipairs(mesecon:rule2meta(rulename, rules)) do
-			local np = mesecon:addPosRule(pos, rule)
-			if mesecon:rules_link(np, pos) then
-				if mesecon:find_receptor_on(np, checked, mesecon:invertRule(rule)) 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)
+-- Get all linking inputrules of inputnode (effector or conductor) that is connected to
+-- outputnode (receptor or conductor) at position `output` and has an output in direction `rule`
+function mesecon.rules_link_rule_all(output, rule)
+	local input = vector.add(output, rule)
+	local inputnode = mesecon.get_node_force(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  mesecon:cmpPos(mesecon:addPosRule(input, inputrule), output) then
-			if inputrule.sx == nil or rule.sx == nil or mesecon:cmpSpecial(inputrule, rule) then
-				rules[#rules+1] = inputrule
+		if  vector.equals(vector.add(input, inputrule), output) then
+			table.insert(rules, inputrule)
 		end
 	end
+
+	return rules
+end
+
+-- Get all linking outputnodes of outputnode (receptor or conductor) that is connected to
+-- inputnode (effector or conductor) at position `input` and has an input in direction `rule`
+function mesecon.rules_link_rule_all_inverted(input, rule)
+	local output = vector.add(input, rule)
+	local outputnode = mesecon.get_node_force(output)
+	local outputrules = mesecon.get_any_outputrules(outputnode)
+	if not outputrules then
+		return {}
+	end
+	local rules = {}
+
+	for _, outputrule in ipairs(mesecon.flattenrules(outputrules)) do
+		if  vector.equals(vector.add(output, outputrule), input) then
+			table.insert(rules, mesecon.invertRule(outputrule))
+		end
 	end
 	return rules
 end
 
-function mesecon:rules_link_anydir(pos1, pos2)
-	return mesecon:rules_link(pos1, pos2) or mesecon:rules_link(pos2, pos1)
-end
-
-function mesecon:is_powered(pos, rule)
-	local node = minetest.get_node(pos)
-	local rules = mesecon:get_any_inputrules(node)
+function mesecon.is_powered(pos, rule)
+	local node = mesecon.get_node_force(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
-			local np = mesecon:addPosRule(pos, rule)
-			local nn = minetest.get_node(np)
+		for _, rule in ipairs(mesecon.flattenrules(rules)) do
+			local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
+			for _, rname in ipairs(rulenames) do
+				local np = vector.add(pos, rname)
+				local nn = mesecon.get_node_force(np)
 
-			if (mesecon:is_conductor_on (nn, mesecon:invertRule(rule)) or mesecon:is_receptor_on (nn.name))
-			and mesecon:rules_link(np, pos) then
-				return true
+				if (mesecon.is_conductor_on(nn, mesecon.invertRule(rname))
+				or mesecon.is_receptor_on(nn.name)) then
+					table.insert(sourcepos, np)
+				end
 			end
 		end
 	else
-		local np = mesecon:addPosRule(pos, rule)
-		local nn = minetest.get_node(np)
-
-		if (mesecon:is_conductor_on (nn, mesecon:invertRule(rule)) or mesecon:is_receptor_on (nn.name))
-		and mesecon:rules_link(np, pos) then
-			return true
+		local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
+		for _, rname in ipairs(rulenames) do
+			local np = vector.add(pos, rname)
+			local nn = mesecon.get_node_force(np)
+			if (mesecon.is_conductor_on (nn, mesecon.invertRule(rname))
+			or mesecon.is_receptor_on (nn.name)) then
+				table.insert(sourcepos, np)
+			end
 		end
 	end
 
-	return false
-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
+	-- Return FALSE if not powered, return list of sources if is powered
+	if (#sourcepos == 0) then return false
+	else return sourcepos end
 end

mesecons/legacy.lua

@@ -1,5 +1,14 @@
-minetest.swap_node = minetest.swap_node or function(pos, node)
-	local data = minetest.get_meta(pos):to_table()
-	minetest.add_node(pos, node)
-	minetest.get_meta(pos):from_table(data)
+-- Un-forceload any forceloaded mapblocks from older versions of Mesecons which
+-- used forceloading instead of VoxelManipulators.
+local BLOCKSIZE = 16
+
+-- 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")
+for hash, _ in pairs(old_forceloaded_blocks) do
+	minetest.forceload_free_block(unhash_blockpos(hash))
+end
+os.remove(minetest.get_worldpath()..DIR_DELIM.."mesecon_forceloaded")

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 = true,
+	is_ground_content = false,
 	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 = true,
+	is_ground_content = false,
 	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 = LIGHT_MAX-11,
+	light_source = minetest.LIGHT_MAX-11,
 	mesecons = {conductor={
 		state = mesecon.state.on,
 		offstate = "mesecons:mesecon_off"

mesecons/presets.lua

@@ -1,44 +1,85 @@
 mesecon.rules = {}
 mesecon.state = {}
 
-mesecon.rules.default =
-{{x=0,  y=0,  z=-1},
- {x=1,  y=0,  z=0},
- {x=-1, y=0,  z=0},
- {x=0,  y=0,  z=1},
- {x=1,  y=1,  z=0},
- {x=1,  y=-1, z=0},
- {x=-1, y=1,  z=0},
- {x=-1, y=-1, z=0},
- {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.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}}
-
-mesecon.rules.flat =
-{{x = 1, y = 0, z = 0},
- {x =-1, y = 0, z = 0},
+mesecon.rules.default = {
+	{x =  0, y =  0, z = -1},
+	{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 =  1, y =  1, z =  0},
+	{x =  1, y = -1, z =  0},
+	{x = -1, y =  1, z =  0},
+	{x = -1, y = -1, z =  0},
+	{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.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},
+}
+
+mesecon.rules.flat = {
+	{x =  1, y = 0, z =  0},
+	{x = -1, y = 0, z =  0},
+	{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 rules = mesecon.rules.buttonlike
-	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
+	local dir = minetest.facedir_to_dir(node.param2)
+	return rules_from_dir(rules_buttonlike, dir)
 end
 
 mesecon.state.on = "on"

mesecons/services.lua

@@ -1,38 +1,136 @@
-mesecon.on_placenode = function (pos, node)
-	if mesecon:is_receptor_on(node.name) then
-		mesecon:receptor_on(pos, mesecon:receptor_get_rules(node))
-	elseif mesecon:is_powered(pos) then
-		if mesecon:is_conductor(node.name) then
-			mesecon:turnon (pos)
-			--mesecon:receptor_on (pos, mesecon:conductor_get_rules(node))
+-- 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
+		mesecon.receptor_on(pos, mesecon.receptor_get_rules(node))
+	end
+
+	-- Conductors: Send turnon signal when powered or replace by respective offstate conductor
+	-- if placed conductor is an onstate one
+	if mesecon.is_conductor(node.name) then
+		local sources = mesecon.is_powered(pos)
+		if sources then
+			-- also call receptor_on if itself is powered already, so that neighboring
+			-- conductors will be activated (when pushing an on-conductor with a piston)
+			for _, s in ipairs(sources) do
+				local rule = vector.subtract(pos, s)
+				mesecon.turnon(pos, rule)
+			end
+			--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
+		local powered_rules = {}
+		local unpowered_rules = {}
+
+		-- for each input rule, check if powered
+		for _, r in ipairs(mesecon.effector_get_rules(node)) do
+			local powered = mesecon.is_powered(pos, r)
+			if powered then table.insert(powered_rules, r)
+			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
-			mesecon:changesignal(pos, node, mesecon:effector_get_rules(node), "on")
-			mesecon:activate(pos, node)
+			for _, r in ipairs(unpowered_rules) do
+				mesecon.deactivate(pos, node, r, 1)
+			end
 		end
-	elseif mesecon:is_conductor_on(node) then
-		minetest.swap_node(pos, {name = mesecon:get_conductor_off(node)})
-	elseif mesecon:is_effector_on (node.name) then
-		mesecon:deactivate(pos, node)
 	end
 end
 
-mesecon.on_dignode = function (pos, node)
-	if mesecon:is_conductor_on(node) then
-		mesecon:receptor_off_i(pos, mesecon:conductor_get_rules(node))
-	elseif mesecon:is_receptor_on(node.name) then
-		mesecon:receptor_off(pos, mesecon:receptor_get_rules(node))
+mesecon.on_dignode = function(pos, node)
+	if mesecon.is_conductor_on(node) then
+		mesecon.receptor_off(pos, mesecon.conductor_get_rules(node))
+	elseif mesecon.is_receptor_on(node.name) then
+		mesecon.receptor_off(pos, mesecon.receptor_get_rules(node))
 	end
+
+	mesecon.execute_autoconnect_hooks_queue(pos, node)
 end
 
-minetest.register_abm({
-	nodenames = {"group:overheat"},
-	interval = 1.0,
-	chance = 1,
-	action = function(pos, node, active_object_count, active_object_count_wider)
-		local meta = minetest.get_meta(pos)
-		meta:set_int("heat",0)
-	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)
+	local id = minetest.hash_node_position(pos)
+	local heat = (object_heat[id] or 0) + 1
+	object_heat[id] = heat
+	if heat >= OVERHEAT_MAX then
+		minetest.log("action", "Node overheats at " .. minetest.pos_to_string(pos))
+		object_heat[id] = nil
+		return true
+	end
+	return false
+end
+
+function mesecon.do_cooldown(pos)
+	local id = minetest.hash_node_position(pos)
+	object_heat[id] = nil
+end
+
+function mesecon.get_heat(pos)
+	local id = minetest.hash_node_position(pos)
+	return object_heat[id] or 0
+end
+
+function mesecon.move_hot_nodes(moved_nodes)
+	local new_heat = {}
+	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
+		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,9 +1,15 @@
 -- SETTINGS
-BLINKY_PLANT_INTERVAL = 3
-NEW_STYLE_WIRES  = true  -- true = new nodebox wires, false = old raillike wires
-PRESSURE_PLATE_INTERVAL = 0.1
-OBJECT_DETECTOR_RADIUS = 6
-PISTON_MAXIMUM_PUSH = 15
-MOVESTONE_MAXIMUM_PUSH = 100
-MESECONS_GLOBALSTEP = true	-- true = receptors/effectors won't be updated
-				-- until next globalstep, decreases server load
+function mesecon.setting(setting, default)
+	if type(default) == "boolean" then
+		local read = minetest.settings:get_bool("mesecon."..setting)
+		if read == nil then
+			return default
+		else
+			return read
+		end
+	elseif type(default) == "string" then
+		return minetest.settings:get("mesecon."..setting) or default
+	elseif type(default) == "number" then
+		return tonumber(minetest.settings:get("mesecon."..setting) or default)
+	end
+end

mesecons/util.lua

@@ -1,24 +1,62 @@
-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.add_node(newpos, node)
+	minetest.set_node(newpos, node)
 	minetest.get_meta(pos):from_table(meta)
 end
 
---[[ new functions:
-mesecon:flattenrules(allrules)
-mesecon:rule2bit(findrule, allrules)
-mesecon:rule2meta(findrule, allrules)
-dec2bin(n)
-mesecon:getstate(nodename, states)
-mesecon:getbinstate(nodename, states)
-mesecon:get_bit(binary, bit)
-mesecon:set_bit(binary, bit, value)
-mesecon:invertRule(r)
---]]
+-- Rules rotation Functions:
+function mesecon.rotate_rules_right(rules)
+	local nr = {}
+	for i, rule in ipairs(rules) do
+		table.insert(nr, {
+			x = -rule.z,
+			y =  rule.y,
+			z =  rule.x,
+			name = rule.name})
+	end
+	return nr
+end
 
-function mesecon:flattenrules(allrules)
+function mesecon.rotate_rules_left(rules)
+	local nr = {}
+	for i, rule in ipairs(rules) do
+		table.insert(nr, {
+			x =  rule.z,
+			y =  rule.y,
+			z = -rule.x,
+			name = rule.name})
+	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)
 --[[
 	{
 		{
@@ -53,7 +91,7 @@ function mesecon:flattenrules(allrules)
 --]]
 end
 
-function mesecon:rule2bit(findrule, allrules)
+function mesecon.rule2bit(findrule, allrules)
 	--get the bit of the metarule the rule is in, or bit 1
 	if (allrules[1] and
 	    allrules[1].x) or
@@ -62,35 +100,36 @@ function mesecon:rule2bit(findrule, allrules)
 	end
 	for m,metarule in ipairs( allrules) do
 	for _,    rule in ipairs(metarule ) do
-		if mesecon:cmpPos(findrule, rule) and mesecon:cmpSpecial(findrule, rule) then
+		if vector.equals(findrule, rule) then
 			return m
 		end
 	end
 	end
 end
 
-function mesecon:rule2metaindex(findrule, allrules)
+function mesecon.rule2metaindex(findrule, allrules)
 	--get the metarule the rule is in, or allrules
-
 	if allrules[1].x then
 		return nil
 	end
 
 	if not(findrule) then
-		return mesecon:flattenrules(allrules)
+		return mesecon.flattenrules(allrules)
 	end
 
 	for m, metarule in ipairs( allrules) do
 	for _,     rule in ipairs(metarule ) do
-		if mesecon:cmpPos(findrule, rule) and mesecon:cmpSpecial(findrule, rule) then
+		if vector.equals(findrule, rule) then
 			return m
 		end
 	end
 	end
 end
 
-function mesecon:rule2meta(findrule, allrules)
-	local index = mesecon:rule2metaindex(findrule, allrules)
+function mesecon.rule2meta(findrule, allrules)
+	if #allrules == 0 then return {} end
+
+	local index = mesecon.rule2metaindex(findrule, allrules)
 	if index == nil then
 		if allrules[1].x then
 			return allrules
@@ -101,25 +140,16 @@ function mesecon:rule2meta(findrule, allrules)
 	return allrules[index]
 end
 
-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)
+function mesecon.dec2bin(n)
 	local x, y = math.floor(n / 2), n % 2
 	if (n > 1) then
-			return dec2bin(x)..y
+		return mesecon.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
@@ -128,52 +158,41 @@ function mesecon:getstate(nodename, states)
 	error(nodename.." doesn't mention itself in "..dump(states))
 end
 
-function mesecon:getbinstate(nodename, states)
-	return dec2bin(mesecon:getstate(nodename, states)-1)
+function mesecon.getbinstate(nodename, states)
+	return mesecon.dec2bin(mesecon.getstate(nodename, states)-1)
 end
 
-function mesecon:get_bit(binary,bit)
+function mesecon.get_bit(binary,bit)
 	bit = bit or 1
 	local c = binary:len()-(bit-1)
 	return binary:sub(c,c) == "1"
 end
 
-function mesecon:set_bit(binary,bit,value)
+function mesecon.set_bit(binary,bit,value)
 	if value == "1" then
-		if not mesecon:get_bit(binary,bit) then
-			return dec2bin(tonumber(binary,2)+math.pow(2,bit-1))
+		if not mesecon.get_bit(binary,bit) then
+			return mesecon.dec2bin(tonumber(binary,2)+math.pow(2,bit-1))
 		end
 	elseif value == "0" then
-		if mesecon:get_bit(binary,bit) then
-			return dec2bin(tonumber(binary,2)-math.pow(2,bit-1))
+		if mesecon.get_bit(binary,bit) then
+			return mesecon.dec2bin(tonumber(binary,2)-math.pow(2,bit-1))
 		end
 	end
 	return binary
 
 end
 
-function mesecon:invertRule(r)
-	return {x = -r.x, y = -r.y, z = -r.z, sx = r.sx, sy = r.sy, sz = r.sz}
+function mesecon.invertRule(r)
+	return vector.multiply(r, -1)
 end
 
-function mesecon:addPosRule(p, r)
-	return {x = p.x + r.x, y = p.y + r.y, z = p.z + r.z}
-end
-
-function mesecon:cmpPos(p1, p2)
-	return (p1.x == p2.x and p1.y == p2.y and p1.z == p2.z)
-end
-
-function mesecon:cmpSpecial(r1, r2)
-	return (r1.sx == r2.sx and r1.sy == r2.sy and r1.sz == r2.sz)
-end
-
-function mesecon:tablecopy(table) -- deep table copy
+function mesecon.tablecopy(table) -- deep table copy
+	if type(table) ~= "table" then return table end -- no need to copy
 	local newtable = {}
 
 	for idx, item in pairs(table) do
 		if type(item) == "table" then
-			newtable[idx] = mesecon:tablecopy(item)
+			newtable[idx] = mesecon.tablecopy(item)
 		else
 			newtable[idx] = item
 		end
@@ -181,3 +200,242 @@ function mesecon:tablecopy(table) -- deep table copy
 
 	return newtable
 end
+
+function mesecon.cmpAny(t1, t2)
+	if type(t1) ~= type(t2) then return false end
+	if type(t1) ~= "table" and type(t2) ~= "table" then return t1 == t2 end
+
+	for i, e in pairs(t1) do
+		if not mesecon.cmpAny(e, t2[i]) then return false end
+	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

@@ -1,280 +0,0 @@
--- 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_blinkyplant/doc/blinkyplant/description.html

@@ -0,0 +1,2 @@
+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,102 +1,52 @@
 -- The BLINKY_PLANT
-minetest.register_node("mesecons_blinkyplant:blinky_plant", {
-	drawtype = "plantlike",
-	visual_scale = 1,
-	tiles = {"jeija_blinky_plant_off.png"},
-	inventory_image = "jeija_blinky_plant_off.png",
-	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},
-	},
-	mesecons = {receptor = {
-		state = mesecon.state.off
-	}},
-	on_rightclick = function(pos, node, clicker)
-        minetest.set_node(pos, {name="mesecons_blinkyplant:blinky_plant_off"})
-    end	
-})
 
-minetest.register_node("mesecons_blinkyplant:blinky_plant_off", {
-	drawtype = "plantlike",
-	visual_scale = 1,
-	tiles = {"jeija_blinky_plant_off.png"},
-	inventory_image = "jeija_blinky_plant_off.png",
-	paramtype = "light",
-	walkable = false,
-	groups = {dig_immediate=3, mesecon=2},
+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",
-	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"},
 	inventory_image = "jeija_blinky_plant_off.png",
 	paramtype = "light",
+	is_ground_content = false,
 	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
+	on_timer = on_timer,
+	on_rightclick = toggle_timer,
+	on_construct = toggle_timer
+},{
+	tiles = {"jeija_blinky_plant_off.png"},
+	groups = {dig_immediate=3},
+	mesecons = {receptor = { state = mesecon.state.off }}
+},{
+	tiles = {"jeija_blinky_plant_on.png"},
+	groups = {dig_immediate=3, not_in_creative_inventory=1},
+	mesecons = {receptor = { state = mesecon.state.on }}
 })
 
 minetest.register_craft({
 	output = "mesecons_blinkyplant:blinky_plant_off 1",
-	recipe = {
+	recipe = {	{"","group:mesecon_conductor_craftable",""},
 			{"","group:mesecon_conductor_craftable",""},
-	{"","group:mesecon_conductor_craftable",""},
-	{"default:sapling","default:sapling","default:sapling"},
-	}
-})
-
-minetest.register_abm(
-	{nodenames = {"mesecons_blinkyplant:blinky_plant_off"},
-	interval = BLINKY_PLANT_INTERVAL,
-	chance = 1,
-	action = function(pos, node, active_object_count, active_object_count_wider)
-		--minetest.remove_node(pos)
-		minetest.add_node(pos, {name="mesecons_blinkyplant:blinky_plant_on"})
-		nodeupdate(pos)	
-		mesecon:receptor_on(pos)
-	end,
-})
-
-minetest.register_abm({
-	nodenames = {"mesecons_blinkyplant:blinky_plant_on"},
-	interval = BLINKY_PLANT_INTERVAL,
-	chance = 1,
-	action = function(pos, node, active_object_count, active_object_count_wider)
-		--minetest.remove_node(pos)
-		minetest.add_node(pos, {name="mesecons_blinkyplant:blinky_plant_off"})
-		nodeupdate(pos)	
-		mesecon:receptor_off(pos)
-	end,
+			{"group:sapling","group:sapling","group:sapling"}}
 })

mesecons_button/doc/button/description.html

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

mesecons_button/init.lua

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

@@ -0,0 +1,2 @@
+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

@@ -23,14 +23,6 @@ minetest.register_chatcommand("tell", {
 	end
 })
 
-minetest.register_chatcommand("tellme", {
-	params = "<text>",
-	description = "Say <text> to yourself",
-	func = function(name, param)
-		minetest.chat_send_player(name, param, false)
-	end
-})
-
 minetest.register_chatcommand("hp", {
 	params = "<name> <value>",
 	description = "Set health of <name> to <value> hitpoints",
@@ -50,16 +42,13 @@ minetest.register_chatcommand("hp", {
 	end
 })
 
-local initialize_data = function(meta, player, command, param)
+local function initialize_data(meta)
+	local commands = minetest.formspec_escape(meta:get_string("commands"))
 	meta:set_string("formspec",
-		"invsize[9,6;]" ..
-		"field[1,1;7.5,1;player;Player;" .. player .. "]" ..
-		"button[1.3,2;2,1;nearest;Nearest]" ..
-		"button[3.3,2;2,1;farthest;Farthest]" ..
-		"button[5.3,2;2,1;random;Random]" ..
-		"field[1,4;2,1;command;Command;" .. command .. "]" ..
-		"field[3,4;5.5,1;param;Parameter;" .. param .. "]" ..
-		"button_exit[3.3,5;2,1;submit;Submit]")
+		"invsize[9,5;]" ..
+		"textarea[0.5,0.5;8.5,4;commands;Commands;"..commands.."]" ..
+		"label[1,3.8;@nearest, @farthest, and @random are replaced by the respective player names]" ..
+		"button_exit[3.3,4.5;2,1;submit;Submit]")
 	local owner = meta:get_string("owner")
 	if owner == "" then
 		owner = "not owned"
@@ -68,81 +57,77 @@ local initialize_data = function(meta, player, command, param)
 	end
 	meta:set_string("infotext", "Command Block\n" ..
 		"(" .. owner .. ")\n" ..
-		"Command: /" .. command .. " " .. param)
+		"Commands: "..commands)
 end
 
-local construct = function(pos)
+local function construct(pos)
 	local meta = minetest.get_meta(pos)
 
-	meta:set_string("player", "@nearest")
-	meta:set_string("command", "time")
-	meta:set_string("param", "7000")
+	meta:set_string("commands", "tell @nearest Commandblock unconfigured")
 
 	meta:set_string("owner", "")
 
-	initialize_data(meta, "@nearest", "time", "7000")
+	initialize_data(meta)
 end
 
-local after_place = function(pos, placer)
+local function after_place(pos, placer)
 	if placer then
 		local meta = minetest.get_meta(pos)
 		meta:set_string("owner", placer:get_player_name())
-		initialize_data(meta, "@nearest", "time", "7000")
+		initialize_data(meta)
 	end
 end
 
-local receive_fields = function(pos, formname, fields, sender)
-	if fields.quit then
+local function receive_fields(pos, formname, fields, sender)
+	if not fields.submit then
 		return
 	end
 	local meta = minetest.get_meta(pos)
-	if fields.nearest then
-		initialize_data(meta, "@nearest", fields.command, fields.param)
-	elseif fields.farthest then
-		initialize_data(meta, "@farthest", fields.command, fields.param)
-	elseif fields.random then
-		initialize_data(meta, "@random", fields.command, fields.param)
-	else --fields.submit or pressed enter
-		meta:set_string("player", fields.player)
-		meta:set_string("command", fields.command)
-		meta:set_string("param", fields.param)
-
-		initialize_data(meta, fields.player, fields.command, fields.param)
+	local owner = meta:get_string("owner")
+	if owner ~= "" and sender:get_player_name() ~= owner then
+		return
 	end
+	meta:set_string("commands", fields.commands)
+
+	initialize_data(meta)
 end
 
-local resolve_player = function(name, pos)
-	local get_distance = function(pos1, pos2)
-		return math.sqrt((pos1.x - pos2.x) ^ 2 + (pos1.y - pos2.y) ^ 2 + (pos1.z - pos2.z) ^ 2)
+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
 
-	if name == "@nearest" then
-		local min_distance = math.huge
-		for index, player in ipairs(minetest.get_connected_players()) do
-			local distance = get_distance(pos, player:getpos())
+	local nearest, farthest = nil, nil
+	local min_distance, max_distance = math.huge, -1
+	for index, player in pairs(players) do
+		local distance = vector.distance(pos, player:getpos())
 		if distance < min_distance then
 			min_distance = distance
-				name = player:get_player_name()
+			nearest = player:get_player_name()
 		end
-		end
-	elseif name == "@farthest" then
-		local max_distance = -1
-		for index, player in ipairs(minetest.get_connected_players()) do
-			local distance = get_distance(pos, player:getpos())
 		if distance > max_distance then
 			max_distance = distance
-				name = player:get_player_name()
+			farthest = player:get_player_name()
 		end
 	end
-	elseif name == "@random" then
-		local players = minetest.get_connected_players()
-		local player = players[math.random(#players)]
-		name = player:get_player_name()
-	end
-	return name
+	local random = players[math.random(#players)]:get_player_name()
+	commands = commands:gsub("@nearest", nearest)
+	commands = commands:gsub("@farthest", farthest)
+	commands = commands:gsub("@random", random)
+	return commands
 end
 
-local commandblock_action_on = function(pos, node)
+local function commandblock_action_on(pos, node)
 	if node.name ~= "mesecons_commandblock:commandblock_off" then
 		return
 	end
@@ -150,61 +135,78 @@ local commandblock_action_on = function(pos, node)
 	minetest.swap_node(pos, {name = "mesecons_commandblock:commandblock_on"})
 
 	local meta = minetest.get_meta(pos)
-	local command = minetest.chatcommands[meta:get_string("command")]
-	if command == nil then
-		return
-	end
 	local owner = meta:get_string("owner")
 	if owner == "" then
 		return
 	end
-	local has_privs, missing_privs = minetest.check_player_privs(owner, command.privs)
-	if not has_privs then
-		minetest.chat_send_player(owner, "You don't have permission to run this command (missing privileges: "..table.concat(missing_privs, ", ")..")")
+
+	local commands = resolve_commands(meta:get_string("commands"), pos)
+	for _, command in pairs(commands:split("\n")) do
+		local pos = command:find(" ")
+		local cmd, param = command, ""
+		if pos then
+			cmd = command:sub(1, pos - 1)
+			param = command:sub(pos + 1)
+		end
+		local cmddef = minetest.chatcommands[cmd]
+		if not cmddef then
+			minetest.chat_send_player(owner, "The command "..cmd.." does not exist")
 			return
 		end
-	local player = resolve_player(meta:get_string("player"), pos)
-	command.func(player, meta:get_string("param"))
+		local has_privs, missing_privs = minetest.check_player_privs(owner, cmddef.privs)
+		if not has_privs then
+			minetest.chat_send_player(owner, "You don't have permission "
+					.."to run "..cmd
+					.." (missing privileges: "
+					..table.concat(missing_privs, ", ")..")")
+			return
+		end
+		cmddef.func(owner, param)
+	end
 end
 
-local commandblock_action_off = function(pos, node)
+local function commandblock_action_off(pos, node)
 	if node.name == "mesecons_commandblock:commandblock_on" then
 		minetest.swap_node(pos, {name = "mesecons_commandblock:commandblock_off"})
 	end
 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()
+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,
 	on_receive_fields = receive_fields,
-	can_dig = function(pos,player)
-		local owner = minetest.get_meta(pos):get_string("owner")
-		return owner == "" or owner == player:get_player_name()
-	end,
+	can_dig = can_dig,
 	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",
 	on_construct = construct,
 	after_place_node = after_place,
 	on_receive_fields = receive_fields,
-	can_dig = function(pos,player)
-		local owner = minetest.get_meta(pos):get_string("owner")
-		return owner == "" or owner == player:get_player_name()
-	end,
+	can_dig = can_dig,
 	sounds = default.node_sound_stone_defaults(),
 	mesecons = {effector = {
 		action_off = commandblock_action_off
-	}}
+	}},
+	on_blast = mesecon.on_blastnode,
 })

mesecons_compatibility/init.lua

@@ -1,167 +0,0 @@
-doors = {}
-
--- Registers a door - REDEFINITION ONLY | DOORS MOD MUST HAVE BEEN LOADED BEFORE
---  name: The name of the door
---  def: a table with the folowing fields:
---    description
---    inventory_image
---    groups
---    tiles_bottom: the tiles of the bottom part of the door {front, side}
---    tiles_top: the tiles of the bottom part of the door {front, side}
---    If the following fields are not defined the default values are used
---    node_box_bottom
---    node_box_top
---    selection_box_bottom
---    selection_box_top
---    only_placer_can_open: if true only the player who placed the door can
---                          open it
-
-function doors:register_door(name, def)
-	def.groups.not_in_creative_inventory = 1
-	
-	local box = {{-0.5, -0.5, -0.5,   0.5, 0.5, -0.5+1.5/16}}
-	
-	if not def.node_box_bottom then
-		def.node_box_bottom = box
-	end
-	if not def.node_box_top then
-		def.node_box_top = box
-	end
-	if not def.selection_box_bottom then
-		def.selection_box_bottom= box
-	end
-	if not def.selection_box_top then
-		def.selection_box_top = box
-	end
-	
-	local tt = def.tiles_top
-	local tb = def.tiles_bottom
-	
-	local function after_dig_node(pos, name)
-		if minetest.get_node(pos).name == name then
-			minetest.remove_node(pos)
-		end
-	end
-
-	local function on_rightclick(pos, dir, check_name, replace, replace_dir, params)
-		pos.y = pos.y+dir
-		if not minetest.get_node(pos).name == check_name then
-			return
-		end
-		local p2 = minetest.get_node(pos).param2
-		p2 = params[p2+1]
-		
-		local meta = minetest.get_meta(pos):to_table()
-		minetest.set_node(pos, {name=replace_dir, param2=p2})
-		minetest.get_meta(pos):from_table(meta)
-		
-		pos.y = pos.y-dir
-		meta = minetest.get_meta(pos):to_table()
-		minetest.set_node(pos, {name=replace, param2=p2})
-		minetest.get_meta(pos):from_table(meta)
-	end
-
-	local function on_mesecons_signal_open (pos, node)
-		on_rightclick(pos, 1, name.."_t_1", name.."_b_2", name.."_t_2", {1,2,3,0})
-	end
-
-	local function on_mesecons_signal_close (pos, node)
-		on_rightclick(pos, 1, name.."_t_2", name.."_b_1", name.."_t_1", {3,0,1,2})
-	end
-	
-	local function check_player_priv(pos, player)
-		if not def.only_placer_can_open then
-			return true
-		end
-		local meta = minetest.get_meta(pos)
-		local pn = player:get_player_name()
-		return meta:get_string("doors_owner") == pn
-	end
-	
-	minetest.register_node(":"..name.."_b_1", {
-		tiles = {tb[2], tb[2], tb[2], tb[2], tb[1], tb[1].."^[transformfx"},
-		paramtype = "light",
-		paramtype2 = "facedir",
-		drop = name,
-		drawtype = "nodebox",
-		node_box = {
-			type = "fixed",
-			fixed = def.node_box_bottom
-		},
-		selection_box = {
-			type = "fixed",
-			fixed = def.selection_box_bottom
-		},
-		groups = def.groups,
-		
-		after_dig_node = function(pos, oldnode, oldmetadata, digger)
-			pos.y = pos.y+1
-			after_dig_node(pos, name.."_t_1")
-		end,
-		
-		on_rightclick = function(pos, node, puncher)
-			if check_player_priv(pos, puncher) then
-				on_rightclick(pos, 1, name.."_t_1", name.."_b_2", name.."_t_2", {1,2,3,0})
-			end
-		end,
-
-		mesecons = {effector = {
-			action_on  = on_mesecons_signal_open
-		}},
-		
-		can_dig = check_player_priv,
-	})
-	
-	minetest.register_node(":"..name.."_b_2", {
-		tiles = {tb[2], tb[2], tb[2], tb[2], tb[1].."^[transformfx", tb[1]},
-		paramtype = "light",
-		paramtype2 = "facedir",
-		drop = name,
-		drawtype = "nodebox",
-		node_box = {
-			type = "fixed",
-			fixed = def.node_box_bottom
-		},
-		selection_box = {
-			type = "fixed",
-			fixed = def.selection_box_bottom
-		},
-		groups = def.groups,
-		
-		after_dig_node = function(pos, oldnode, oldmetadata, digger)
-			pos.y = pos.y+1
-			after_dig_node(pos, name.."_t_2")
-		end,
-		
-		on_rightclick = function(pos, node, puncher)
-			if check_player_priv(pos, puncher) then
-				on_rightclick(pos, 1, name.."_t_2", name.."_b_1", name.."_t_1", {3,0,1,2})
-			end
-		end,
-
-		mesecons = {effector = {
-			action_off = on_mesecons_signal_close
-		}},
-		
-		can_dig = check_player_priv,
-	})
-end
-
-doors:register_door("doors:door_wood", {
-	description = "Wooden Door",
-	inventory_image = "door_wood.png",
-	groups = {snappy=1,choppy=2,oddly_breakable_by_hand=2,flammable=2,door=1},
-	tiles_bottom = {"door_wood_b.png", "door_brown.png"},
-	tiles_top = {"door_wood_a.png", "door_brown.png"},
-	sounds = default.node_sound_wood_defaults(),
-})
-
-doors:register_door("doors:door_steel", {
-	description = "Steel Door",
-	inventory_image = "door_steel.png",
-	groups = {snappy=1,bendy=2,cracky=1,melty=2,level=2,door=1},
-	tiles_bottom = {"door_steel_b.png", "door_grey.png"},
-	tiles_top = {"door_steel_a.png", "door_grey.png"},
-	only_placer_can_open = true,
-	sounds = default.node_sound_stone_defaults(),
-})

mesecons_delayer/doc/delayer/description.html

@@ -0,0 +1 @@
+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,35 +10,25 @@ 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
 
 -- Functions that are called after the delay time
 
-local delayer_turnon = function(params)
-	local rules = delayer_get_output_rules(params.node)
-	mesecon:receptor_on(params.pos, rules)
-end
-
-local delayer_turnoff = function(params)
-	local rules = delayer_get_output_rules(params.node)
-	mesecon:receptor_off(params.pos, rules)
-end
-
 local delayer_activate = function(pos, node)
 	local def = minetest.registered_nodes[node.name]
 	local time = def.delayer_time
 	minetest.swap_node(pos, {name = def.delayer_onstate, param2=node.param2})
-	minetest.after(time, delayer_turnon , {pos = pos, node = node})
+	mesecon.queue:add_action(pos, "receptor_on", {delayer_get_output_rules(node)}, time, nil)
 end
 
 local delayer_deactivate = function(pos, node)
 	local def = minetest.registered_nodes[node.name]
 	local time = def.delayer_time
 	minetest.swap_node(pos, {name = def.delayer_offstate, param2=node.param2})
-	minetest.after(time, delayer_turnoff, {pos = pos, node = node})
+	mesecon.queue:add_action(pos, "receptor_off", {delayer_get_output_rules(node)}, time, nil)
 end
 
 -- Register the 2 (states) x 4 (delay times) delayers
@@ -57,7 +47,8 @@ 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
+local 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 },
@@ -67,7 +58,8 @@ boxes = {{ -6/16, -8/16, -6/16, 6/16, -7/16, 6/16 },		-- the main slab
 
 	 { -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 }
+}
 
 minetest.register_node("mesecons_delayer:delayer_off_"..tostring(i), {
 	description = "Delayer",
@@ -95,7 +87,7 @@ minetest.register_node("mesecons_delayer:delayer_off_"..tostring(i), {
 	paramtype = "light",
 	paramtype2 = "facedir",
 	sunlight_propagates = true,
-	is_ground_content = true,
+	is_ground_content = false,
 	drop = 'mesecons_delayer:delayer_off_1',
 	on_punch = function (pos, node)
 		if node.name=="mesecons_delayer:delayer_off_1" then
@@ -122,7 +114,8 @@ minetest.register_node("mesecons_delayer:delayer_off_"..tostring(i), {
 			rules = delayer_get_input_rules,
 			action_on = delayer_activate
 		}
-	}
+	},
+	on_blast = mesecon.on_blastnode,
 })
 
 
@@ -150,7 +143,7 @@ minetest.register_node("mesecons_delayer:delayer_on_"..tostring(i), {
 	paramtype = "light",
 	paramtype2 = "facedir",
 	sunlight_propagates = true,
-	is_ground_content = true,
+	is_ground_content = false,
 	drop = 'mesecons_delayer:delayer_off_1',
 	on_punch = function (pos, node)
 		if node.name=="mesecons_delayer:delayer_on_1" then
@@ -165,6 +158,7 @@ minetest.register_node("mesecons_delayer:delayer_on_"..tostring(i), {
 	end,
 	delayer_time = delaytime,
 	delayer_offstate = "mesecons_delayer:delayer_off_"..tostring(i),
+	sounds = default.node_sound_stone_defaults(),
 	mesecons = {
 		receptor =
 		{
@@ -176,7 +170,8 @@ minetest.register_node("mesecons_delayer:delayer_on_"..tostring(i), {
 			rules = delayer_get_input_rules,
 			action_off = delayer_deactivate
 		}
-	}
+	},
+	on_blast = mesecon.on_blastnode,
 })
 end
 

mesecons_detector/doc/nodedetector/description.html

@@ -0,0 +1,8 @@
+The node detector is a receptor. It changes its state when either any node
+or a specific node is detected. Right-click it to set a nodename to scan for.
+It can also receive digiline signals. You can either send "GET" and it will
+respond with the detected nodename or you can send any other string and it will
+set this string as the node to scan for.
+Nodenames must include the mod they reside in, so for instance default:dirt, not just dirt.
+The distance parameter specifies how many blocks are between the node detector and the node to detect.
+Automatic scanning with Mesecons output only works when the detector is in an active block, but Digilines queries always work.

mesecons_detector/doc/objectdetector/description.html

@@ -0,0 +1,5 @@
+The object detector is a receptor. It changes its state when a player approaches.
+Right-click it to set a name to scan for.
+You can also search for comma-separated lists of players where the detector gets activated if any of the names in the list are found.
+It can also receive digiline signals which are the name to scan for on the specified channel in the right-click menu.
+Automatic scanning with Mesecons output only works when the detector is in an active block, but Digilines queries always work.

mesecons_detector/init.lua

@@ -1,18 +1,22 @@
+local GET_COMMAND = "GET"
+
 -- Object detector
 -- Detects players in a certain radius
 -- The radius can be specified in mesecons/settings.lua
 
-local object_detector_make_formspec = function (pos)
+local function object_detector_make_formspec(pos)
 	local meta = minetest.get_meta(pos)
 	meta:set_string("formspec", "size[9,2.5]" ..
 		"field[0.3,  0;9,2;scanname;Name of player to scan for (empty for any):;${scanname}]"..
-		"field[0.3,1.5;4,2;digiline_channel;Digiline Channel (optional):;${digiline_channel}]")
+		"field[0.3,1.5;4,2;digiline_channel;Digiline Channel (optional):;${digiline_channel}]"..
+		"button_exit[7,0.75;2,3;;Save]")
 end
 
-local object_detector_on_receive_fields = function(pos, formname, fields)
-	if fields.quit then
-		return
-	end
+local function object_detector_on_receive_fields(pos, formname, fields, sender)
+	if not fields.scanname or not fields.digiline_channel then return end
+
+	if minetest.is_protected(pos, sender:get_player_name()) then return end
+
 	local meta = minetest.get_meta(pos)
 	meta:set_string("scanname", fields.scanname)
 	meta:set_string("digiline_channel", fields.digiline_channel)
@@ -20,25 +24,38 @@ local object_detector_on_receive_fields = function(pos, formname, fields)
 end
 
 -- returns true if player was found, false if not
-local object_detector_scan = function (pos)
-	local objs = minetest.get_objects_inside_radius(pos, OBJECT_DETECTOR_RADIUS)
-	for k, obj in pairs(objs) do
-		local isname = obj:get_player_name() -- "" is returned if it is not a player; "" ~= nil!
+local function object_detector_scan(pos)
+	local objs = minetest.get_objects_inside_radius(pos, mesecon.setting("detector_radius", 6))
+
+	-- abort if no scan results were found
+	if next(objs) == nil then return false end
+
 	local scanname = minetest.get_meta(pos):get_string("scanname")
-		if (isname == scanname and isname ~= "") or (isname  ~= "" and scanname == "") then -- player with scanname found or not scanname specified
+	local scan_for = {}
+	for _, str in pairs(string.split(scanname:gsub(" ", ""), ",")) do
+		scan_for[str] = true
+	end
+
+	local every_player = scanname == ""
+	for _, obj in pairs(objs) do
+		-- "" is returned if it is not a player; "" ~= nil; so only handle objects with foundname ~= ""
+		local foundname = obj:get_player_name()
+		if foundname ~= "" then
+			if every_player or scan_for[foundname] then
 				return true
 			end
 		end
+	end
+
 	return false
 end
 
 -- set player name when receiving a digiline signal on a specific channel
-object_detector_digiline = {
+local object_detector_digiline = {
 	effector = {
-		action = function (pos, node, channel, msg)
+		action = function(pos, node, channel, msg)
 			local meta = minetest.get_meta(pos)
-			local active_channel = meta:get_string("digiline_channel")
-			if channel == active_channel then
+			if channel == meta:get_string("digiline_channel") then
 				meta:set_string("scanname", msg)
 				object_detector_make_formspec(pos)
 			end
@@ -49,31 +66,37 @@ object_detector_digiline = {
 minetest.register_node("mesecons_detector:object_detector_off", {
 	tiles = {"default_steel_block.png", "default_steel_block.png", "jeija_object_detector_off.png", "jeija_object_detector_off.png", "jeija_object_detector_off.png", "jeija_object_detector_off.png"},
 	paramtype = "light",
+	is_ground_content = false,
 	walkable = true,
 	groups = {cracky=3},
 	description="Player Detector",
 	mesecons = {receptor = {
-		state = mesecon.state.off
+		state = mesecon.state.off,
+		rules = mesecon.rules.pplate
 	}},
 	on_construct = object_detector_make_formspec,
 	on_receive_fields = object_detector_on_receive_fields,
 	sounds = default.node_sound_stone_defaults(),
-	digiline = object_detector_digiline
+	digiline = object_detector_digiline,
+	on_blast = mesecon.on_blastnode,
 })
 
 minetest.register_node("mesecons_detector:object_detector_on", {
 	tiles = {"default_steel_block.png", "default_steel_block.png", "jeija_object_detector_on.png", "jeija_object_detector_on.png", "jeija_object_detector_on.png", "jeija_object_detector_on.png"},
 	paramtype = "light",
+	is_ground_content = false,
 	walkable = true,
 	groups = {cracky=3,not_in_creative_inventory=1},
 	drop = 'mesecons_detector:object_detector_off',
 	mesecons = {receptor = {
-		state = mesecon.state.on
+		state = mesecon.state.on,
+		rules = mesecon.rules.pplate
 	}},
 	on_construct = object_detector_make_formspec,
 	on_receive_fields = object_detector_on_receive_fields,
 	sounds = default.node_sound_stone_defaults(),
-	digiline = object_detector_digiline
+	digiline = object_detector_digiline,
+	on_blast = mesecon.on_blastnode,
 })
 
 minetest.register_craft({
@@ -85,26 +108,208 @@ minetest.register_craft({
 	}
 })
 
-minetest.register_abm(
-	{nodenames = {"mesecons_detector:object_detector_off"},
-	interval = 1.0,
+minetest.register_craft({
+	output = 'mesecons_detector:object_detector_off',
+	recipe = {
+		{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
+		{"default:steel_ingot", "mesecons_microcontroller:microcontroller0000", "default:steel_ingot"},
+		{"default:steel_ingot", "group:mesecon_conductor_craftable", "default:steel_ingot"},
+	}
+})
+
+minetest.register_abm({
+	nodenames = {"mesecons_detector:object_detector_off"},
+	interval = 1,
 	chance = 1,
-	action = function(pos)
-		if object_detector_scan(pos) then
-			minetest.swap_node(pos, {name = "mesecons_detector:object_detector_on"})
-			mesecon:receptor_on(pos)
-		end
+	action = function(pos, node)
+		if not object_detector_scan(pos) then return end
+
+		node.name = "mesecons_detector:object_detector_on"
+		minetest.swap_node(pos, node)
+		mesecon.receptor_on(pos, mesecon.rules.pplate)
 	end,
 })
 
-minetest.register_abm(
-	{nodenames = {"mesecons_detector:object_detector_on"},
-	interval = 1.0,
+minetest.register_abm({
+	nodenames = {"mesecons_detector:object_detector_on"},
+	interval = 1,
 	chance = 1,
-	action = function(pos)
-		if not object_detector_scan(pos) then
-			minetest.swap_node(pos, {name = "mesecons_detector:object_detector_off"})
-			mesecon:receptor_off(pos)
-		end
+	action = function(pos, node)
+		if object_detector_scan(pos) then return end
+
+		node.name = "mesecons_detector:object_detector_off"
+		minetest.swap_node(pos, node)
+		mesecon.receptor_off(pos, mesecon.rules.pplate)
+	end,
+})
+
+-- Node detector
+-- Detects the node in front of it
+
+local function node_detector_make_formspec(pos)
+	local meta = minetest.get_meta(pos)
+	if meta:get_string("distance") == ""  then meta:set_string("distance", "0") end
+	meta:set_string("formspec", "size[9,2.5]" ..
+		"field[0.3,  0;9,2;scanname;Name of node to scan for (empty for any):;${scanname}]"..
+		"field[0.3,1.5;2.5,2;distance;Distance (0-"..mesecon.setting("node_detector_distance_max", 10).."):;${distance}]"..
+		"field[3,1.5;4,2;digiline_channel;Digiline Channel (optional):;${digiline_channel}]"..
+		"button_exit[7,0.75;2,3;;Save]")
+end
+
+local function node_detector_on_receive_fields(pos, fieldname, fields, sender)
+	if not fields.scanname or not fields.digiline_channel then return end
+
+	if minetest.is_protected(pos, sender:get_player_name()) then return end
+
+	local meta = minetest.get_meta(pos)
+	meta:set_string("scanname", fields.scanname)
+	meta:set_string("distance", fields.distance or "0")
+	meta:set_string("digiline_channel", fields.digiline_channel)
+	node_detector_make_formspec(pos)
+end
+
+-- returns true if node was found, false if not
+local function node_detector_scan(pos)
+	local node = minetest.get_node_or_nil(pos)
+	if not node then return end
+
+	local meta = minetest.get_meta(pos)
+
+	local distance = meta:get_int("distance")
+	local distance_max = mesecon.setting("node_detector_distance_max", 10)
+	if distance < 0 then distance = 0 end
+	if distance > distance_max then distance = distance_max end
+
+	local frontname = minetest.get_node(
+		vector.subtract(pos, vector.multiply(minetest.facedir_to_dir(node.param2), distance + 1))
+	).name
+	local scanname = meta:get_string("scanname")
+
+	return (frontname == scanname) or
+		(frontname ~= "air" and frontname ~= "ignore" and scanname == "")
+end
+
+-- set player name when receiving a digiline signal on a specific channel
+local node_detector_digiline = {
+	effector = {
+		action = function(pos, node, channel, msg)
+			local meta = minetest.get_meta(pos)
+
+			local distance = meta:get_int("distance")
+			local distance_max = mesecon.setting("node_detector_distance_max", 10)
+			if distance < 0 then distance = 0 end
+			if distance > distance_max then distance = distance_max end
+
+			if channel ~= meta:get_string("digiline_channel") then return end
+
+			if msg == GET_COMMAND then
+				local nodename = minetest.get_node(
+					vector.subtract(pos, vector.multiply(minetest.facedir_to_dir(node.param2), distance + 1))
+				).name
+
+				digiline:receptor_send(pos, digiline.rules.default, channel, nodename)
+			else
+				meta:set_string("scanname", msg)
+				node_detector_make_formspec(pos)
+			end
+		end,
+	},
+	receptor = {}
+}
+
+local function after_place_node_detector(pos, placer)
+	local placer_pos = placer:getpos()
+	if not placer_pos then
+		return
+	end
+
+	--correct for the player's height
+	if placer:is_player() then
+		placer_pos.y = placer_pos.y + 1.625
+	end
+
+	--correct for 6d facedir
+	local node = minetest.get_node(pos)
+	node.param2 = minetest.dir_to_facedir(vector.subtract(pos, placer_pos), true)
+	minetest.set_node(pos, node)
+end
+
+minetest.register_node("mesecons_detector:node_detector_off", {
+	tiles = {"default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "jeija_node_detector_off.png"},
+	paramtype = "light",
+	paramtype2 = "facedir",
+	is_ground_content = false,
+	walkable = true,
+	groups = {cracky=3},
+	description="Node Detector",
+	mesecons = {receptor = {
+		state = mesecon.state.off
+	}},
+	on_construct = node_detector_make_formspec,
+	on_receive_fields = node_detector_on_receive_fields,
+	sounds = default.node_sound_stone_defaults(),
+	digiline = node_detector_digiline,
+	on_blast = mesecon.on_blastnode,
+})
+
+minetest.register_node("mesecons_detector:node_detector_on", {
+	tiles = {"default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "jeija_node_detector_on.png"},
+	paramtype = "light",
+	paramtype2 = "facedir",
+	is_ground_content = false,
+	walkable = true,
+	groups = {cracky=3,not_in_creative_inventory=1},
+	drop = 'mesecons_detector:node_detector_off',
+	mesecons = {receptor = {
+		state = mesecon.state.on
+	}},
+	on_construct = node_detector_make_formspec,
+	on_receive_fields = node_detector_on_receive_fields,
+	sounds = default.node_sound_stone_defaults(),
+	digiline = node_detector_digiline,
+	on_blast = mesecon.on_blastnode,
+})
+
+minetest.register_craft({
+	output = 'mesecons_detector:node_detector_off',
+	recipe = {
+		{"default:steel_ingot", "group:mesecon_conductor_craftable", "default:steel_ingot"},
+		{"default:steel_ingot", "mesecons_luacontroller:luacontroller0000", "default:steel_ingot"},
+		{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
+	}
+})
+
+minetest.register_craft({
+	output = 'mesecons_detector:node_detector_off',
+	recipe = {
+		{"default:steel_ingot", "group:mesecon_conductor_craftable", "default:steel_ingot"},
+		{"default:steel_ingot", "mesecons_microcontroller:microcontroller0000", "default:steel_ingot"},
+		{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
+	}
+})
+
+minetest.register_abm({
+	nodenames = {"mesecons_detector:node_detector_off"},
+	interval = 1,
+	chance = 1,
+	action = function(pos, node)
+		if not node_detector_scan(pos) then return end
+
+		node.name = "mesecons_detector:node_detector_on"
+		minetest.swap_node(pos, node)
+		mesecon.receptor_on(pos)
+	end,
+})
+
+minetest.register_abm({
+	nodenames = {"mesecons_detector:node_detector_on"},
+	interval = 1,
+	chance = 1,
+	action = function(pos, node)
+		if node_detector_scan(pos) then return end
+
+		node.name = "mesecons_detector:node_detector_off"
+		minetest.swap_node(pos, node)
+		mesecon.receptor_off(pos)
 	end,
 })

mesecons_doors/init.lua

@@ -0,0 +1,129 @@
+-- Modified, from minetest_game/mods/doors/init.lua
+local function on_rightclick(pos, dir, check_name, replace, replace_dir, params)
+	pos.y = pos.y + dir
+	if not minetest.get_node(pos).name == check_name then
+		return
+	end
+	local p2 = minetest.get_node(pos).param2
+	p2 = params[p2 + 1]
+
+	minetest.swap_node(pos, {name = replace_dir, param2 = p2})
+
+	pos.y = pos.y - dir
+	minetest.swap_node(pos, {name = replace, param2 = p2})
+
+	if (minetest.get_meta(pos):get_int("right") ~= 0) == (params[1] ~= 3) then
+		minetest.sound_play("doors_door_close", {pos = pos, gain = 0.3, max_hear_distance = 10})
+	else
+		minetest.sound_play("doors_door_open", {pos = pos, gain = 0.3, max_hear_distance = 10})
+	end
+end
+
+local function meseconify_door(name)
+	if minetest.registered_items[name .. "_b_1"] then
+		-- old style double-node doors
+		local function toggle_state1 (pos, node)
+			on_rightclick(pos, 1, name.."_t_1", name.."_b_2", name.."_t_2", {1,2,3,0})
+		end
+
+		local function toggle_state2 (pos, node)
+			on_rightclick(pos, 1, name.."_t_2", name.."_b_1", name.."_t_1", {3,0,1,2})
+		end
+
+		minetest.override_item(name.."_b_1", {
+			mesecons = {effector = {
+				action_on = toggle_state1,
+				action_off = toggle_state1,
+				rules = mesecon.rules.pplate
+			}}
+		})
+
+		minetest.override_item(name.."_b_2", {
+			mesecons = {effector = {
+				action_on = toggle_state2,
+				action_off = toggle_state2,
+				rules = mesecon.rules.pplate
+			}}
+		})
+	elseif minetest.registered_items[name .. "_a"] then
+		-- new style mesh node based doors
+		local override = {
+			mesecons = {effector = {
+				action_on = function(pos, node)
+					local door = doors.get(pos)
+					if door then
+						door:open()
+					end
+				end,
+				action_off = function(pos, node)
+					local door = doors.get(pos)
+					if door then
+						door:close()
+					end
+				end,
+				rules = mesecon.rules.pplate
+			}}
+		}
+		minetest.override_item(name .. "_a", override)
+		minetest.override_item(name .. "_b", override)
+	end
+end
+
+meseconify_door("doors:door_wood")
+meseconify_door("doors:door_steel")
+meseconify_door("doors:door_glass")
+meseconify_door("doors:door_obsidian_glass")
+
+-- Trapdoor
+local function trapdoor_switch(pos, node)
+	local state = minetest.get_meta(pos):get_int("state")
+
+	if state == 1 then
+		minetest.sound_play("doors_door_close", {pos = pos, gain = 0.3, max_hear_distance = 10})
+		minetest.set_node(pos, {name="doors:trapdoor", param2 = node.param2})
+	else
+		minetest.sound_play("doors_door_open", {pos = pos, gain = 0.3, max_hear_distance = 10})
+		minetest.set_node(pos, {name="doors:trapdoor_open", param2 = node.param2})
+	end
+
+	minetest.get_meta(pos):set_int("state", state == 1 and 0 or 1)
+end
+
+if doors and doors.get then
+	local override = {
+		mesecons = {effector = {
+			action_on = function(pos, node)
+				local door = doors.get(pos)
+				if door then
+					door:open()
+				end
+			end,
+			action_off = function(pos, node)
+				local door = doors.get(pos)
+				if door then
+					door:close()
+				end
+			end,
+		}},
+	}
+	minetest.override_item("doors:trapdoor", override)
+	minetest.override_item("doors:trapdoor_open", override)
+	minetest.override_item("doors:trapdoor_steel", override)
+	minetest.override_item("doors:trapdoor_steel_open", override)
+else
+	if minetest.registered_nodes["doors:trapdoor"] then
+		minetest.override_item("doors:trapdoor", {
+			mesecons = {effector = {
+				action_on = trapdoor_switch,
+				action_off = trapdoor_switch
+			}},
+		})
+
+		minetest.override_item("doors:trapdoor_open", {
+			mesecons = {effector = {
+				action_on = trapdoor_switch,
+				action_off = trapdoor_switch
+			}},
+		})
+	end
+end

mesecons_extrawires/corner.lua

@@ -1,12 +1,15 @@
+local screwdriver_exists = minetest.global_exists("screwdriver")
+
 local corner_nodebox = {
 	type = "fixed",
+	-- ±0.001 is to prevent z-fighting
 	fixed = {{ -16/32-0.001, -17/32, -3/32, 0, -13/32, 3/32 },
 		   { -3/32, -17/32, -16/32+0.001, 3/32, -13/32, 3/32}}
 }
 
 local corner_selectionbox = {
 		type = "fixed",
-		fixed = { -16/32-0.001, -18/32, -16/32, 5/32, -12/32, 5/32 },
+		fixed = { -16/32, -16/32, -16/32, 5/32, -12/32, 5/32 },
 }
 
 local corner_get_rules = function (node)
@@ -15,7 +18,7 @@ local corner_get_rules = function (node)
 	 {x = 0,  y = 0,  z = -1}}
 
 	for i = 0, node.param2 do
-		rules = mesecon:rotate_rules_left(rules)
+		rules = mesecon.rotate_rules_left(rules)
 	end
 
 	return rules
@@ -33,23 +36,27 @@ minetest.register_node("mesecons_extrawires:corner_on", {
 	},
 	paramtype = "light",
 	paramtype2 = "facedir",
+	is_ground_content = false,
 	walkable = false,
 	sunlight_propagates = true,
 	selection_box = corner_selectionbox,
 	node_box = corner_nodebox,
 	groups = {dig_immediate = 3, not_in_creative_inventory = 1},
 	drop = "mesecons_extrawires:corner_off",
+	sounds = default.node_sound_defaults(),
 	mesecons = {conductor =
 	{
 		state = mesecon.state.on,
 		rules = corner_get_rules,
 		offstate = "mesecons_extrawires:corner_off"
-	}}
+	}},
+	on_blast = mesecon.on_blastnode,
+	on_rotate = screwdriver_exists and screwdriver.rotate_simple,
 })
 
 minetest.register_node("mesecons_extrawires:corner_off", {
 	drawtype = "nodebox",
-	description = "Mesecon Corner",
+	description = "Insulated Mesecon Corner",
 	tiles = {
 		"jeija_insulated_wire_curved_tb_off.png",
 		"jeija_insulated_wire_curved_tb_off.png^[transformR270",
@@ -60,17 +67,21 @@ minetest.register_node("mesecons_extrawires:corner_off", {
 	},
 	paramtype = "light",
 	paramtype2 = "facedir",
+	is_ground_content = false,
 	walkable = false,
 	sunlight_propagates = true,
 	selection_box = corner_selectionbox,
 	node_box = corner_nodebox,
 	groups = {dig_immediate = 3},
+	sounds = default.node_sound_defaults(),
 	mesecons = {conductor =
 	{
 		state = mesecon.state.off,
 		rules = corner_get_rules,
 		onstate = "mesecons_extrawires:corner_on"
-	}}
+	}},
+	on_blast = mesecon.on_blastnode,
+	on_rotate = screwdriver_exists and screwdriver.rotate_simple,
 })
 
 minetest.register_craft({

mesecons_extrawires/crossover.lua

@@ -1,4 +1,4 @@
-function crossover_get_rules(node)
+local function crossover_get_rules(node)
 	return {
 		{--first wire
 			{x=-1,y=0,z=0},
@@ -19,143 +19,110 @@ local crossover_states = {
 }
 
 minetest.register_node("mesecons_extrawires:crossover_off", {
-	description = "Insulated Crossover",
-	drawtype = "nodebox",
+	description = "Insulated Mesecon Crossover",
+	drawtype = "mesh",
+	mesh = "mesecons_extrawires_crossover.b3d",
 	tiles = {
-		"jeija_insulated_wire_crossing_tb_off.png",
-		"jeija_insulated_wire_crossing_tb_off.png",
+		"jeija_insulated_wire_ends_off.png",
+		"jeija_insulated_wire_sides_off.png",
+		"jeija_insulated_wire_sides_off.png",
 		"jeija_insulated_wire_ends_off.png"
 	},
 	paramtype = "light",
+	is_ground_content = false,
 	walkable = false,
 	stack_max = 99,
-	selection_box = {type="fixed", fixed={-16/32-0.0001, -18/32, -16/32-0.001, 16/32+0.001, -5/32, 16/32+0.001}},
-	node_box = {
-		type = "fixed",
-		fixed = {
-			{ -16/32-0.001, -17/32, -3/32, 16/32+0.001, -13/32, 3/32 },
-			{ -3/32, -17/32, -16/32-0.001, 3/32, -13/32, -6/32 },
-			{ -3/32, -13/32, -9/32, 3/32, -6/32, -6/32 },
-			{ -3/32, -9/32, -9/32, 3/32, -6/32, 9/32 },
-			{ -3/32, -13/32, 6/32, 3/32, -6/32, 9/32 },
-			{ -3/32, -17/32, 6/32, 3/32, -13/32, 16/32+0.001 },
-		},
-	},
-	groups = {dig_immediate=3, mesecon=3, mesecon_conductor_craftable=1},
+	selection_box = {type="fixed", fixed={-16/32, -16/32, -16/32, 16/32, -5/32, 16/32}},
+	groups = {dig_immediate=3, mesecon=3},
+	sounds = default.node_sound_defaults(),
 	mesecons = {
 		conductor = {
 			states = crossover_states,
 			rules = crossover_get_rules(),
 		}
 	},
+	on_blast = mesecon.on_blastnode,
 })
 
 minetest.register_node("mesecons_extrawires:crossover_01", {
 	description = "You hacker you!",
 	drop = "mesecons_extrawires:crossover_off",
-	drawtype = "nodebox",
+	drawtype = "mesh",
+	mesh = "mesecons_extrawires_crossover.b3d",
 	tiles = {
-		"jeija_insulated_wire_crossing_tb_01.png",
-		"jeija_insulated_wire_crossing_tb_01.png",
-		"jeija_insulated_wire_ends_01x.png",
-		"jeija_insulated_wire_ends_01x.png",
-		"jeija_insulated_wire_ends_01z.png",
-		"jeija_insulated_wire_ends_01z.png"
+		"jeija_insulated_wire_ends_on.png",
+		"jeija_insulated_wire_sides_on.png",
+		"jeija_insulated_wire_sides_off.png",
+		"jeija_insulated_wire_ends_off.png"
 	},
 	paramtype = "light",
+	is_ground_content = false,
 	walkable = false,
 	stack_max = 99,
-	selection_box = {type="fixed", fixed={-16/32-0.0001, -18/32, -16/32-0.001, 16/32+0.001, -5/32, 16/32+0.001}},
-	node_box = {
-		type = "fixed",
-		fixed = {
-			{ -16/32-0.001, -17/32, -3/32, 16/32+0.001, -13/32, 3/32 },
-			{ -3/32, -17/32, -16/32-0.001, 3/32, -13/32, -6/32 },
-			{ -3/32, -13/32, -9/32, 3/32, -6/32, -6/32 },
-			{ -3/32, -9/32, -9/32, 3/32, -6/32, 9/32 },
-			{ -3/32, -13/32, 6/32, 3/32, -6/32, 9/32 },
-			{ -3/32, -17/32, 6/32, 3/32, -13/32, 16/32+0.001 },
-		},
-	},
-	groups = {dig_immediate=3, mesecon=3, mesecon_conductor_craftable=1, not_in_creative_inventory=1},
+	selection_box = {type="fixed", fixed={-16/32, -16/32, -16/32, 16/32, -5/32, 16/32}},
+	groups = {dig_immediate=3, mesecon=3, not_in_creative_inventory=1},
+	sounds = default.node_sound_defaults(),
 	mesecons = {
 		conductor = {
 			states = crossover_states,
 			rules = crossover_get_rules(),
 		}
 	},
+	on_blast = mesecon.on_blastnode,
 })
 
 minetest.register_node("mesecons_extrawires:crossover_10", {
 	description = "You hacker you!",
 	drop = "mesecons_extrawires:crossover_off",
-	drawtype = "nodebox",
+	drawtype = "mesh",
+	mesh = "mesecons_extrawires_crossover.b3d",
 	tiles = {
-		"jeija_insulated_wire_crossing_tb_10.png",
-		"jeija_insulated_wire_crossing_tb_10.png",
-		"jeija_insulated_wire_ends_10x.png",
-		"jeija_insulated_wire_ends_10x.png",
-		"jeija_insulated_wire_ends_10z.png",
-		"jeija_insulated_wire_ends_10z.png"
+		"jeija_insulated_wire_ends_off.png",
+		"jeija_insulated_wire_sides_off.png",
+		"jeija_insulated_wire_sides_on.png",
+		"jeija_insulated_wire_ends_on.png"
 	},
 	paramtype = "light",
+	is_ground_content = false,
 	walkable = false,
 	stack_max = 99,
-	selection_box = {type="fixed", fixed={-16/32-0.0001, -18/32, -16/32-0.001, 16/32+0.001, -5/32, 16/32+0.001}},
-	node_box = {
-		type = "fixed",
-		fixed = {
-			{ -16/32-0.001, -17/32, -3/32, 16/32+0.001, -13/32, 3/32 },
-			{ -3/32, -17/32, -16/32-0.001, 3/32, -13/32, -6/32 },
-			{ -3/32, -13/32, -9/32, 3/32, -6/32, -6/32 },
-			{ -3/32, -9/32, -9/32, 3/32, -6/32, 9/32 },
-			{ -3/32, -13/32, 6/32, 3/32, -6/32, 9/32 },
-			{ -3/32, -17/32, 6/32, 3/32, -13/32, 16/32+0.001 },
-		},
-	},
-	groups = {dig_immediate=3, mesecon=3, mesecon_conductor_craftable=1, not_in_creative_inventory=1},
+	selection_box = {type="fixed", fixed={-16/32, -16/32, -16/32, 16/32, -5/32, 16/32}},
+	groups = {dig_immediate=3, mesecon=3, not_in_creative_inventory=1},
+	sounds = default.node_sound_defaults(),
 	mesecons = {
 		conductor = {
 			states = crossover_states,
 			rules = crossover_get_rules(),
 		}
 	},
+	on_blast = mesecon.on_blastnode,
 })
 
 minetest.register_node("mesecons_extrawires:crossover_on", {
 	description = "You hacker you!",
 	drop = "mesecons_extrawires:crossover_off",
-	drawtype = "nodebox",
+	drawtype = "mesh",
+	mesh = "mesecons_extrawires_crossover.b3d",
 	tiles = {
-		"jeija_insulated_wire_crossing_tb_on.png",
-		"jeija_insulated_wire_crossing_tb_on.png",
-		"jeija_insulated_wire_ends_on.png",
-		"jeija_insulated_wire_ends_on.png",
 		"jeija_insulated_wire_ends_on.png",
+		"jeija_insulated_wire_sides_on.png",
+		"jeija_insulated_wire_sides_on.png",
 		"jeija_insulated_wire_ends_on.png"
 	},
 	paramtype = "light",
+	is_ground_content = false,
 	walkable = false,
 	stack_max = 99,
-	selection_box = {type="fixed", fixed={-16/32-0.0001, -18/32, -16/32-0.001, 16/32+0.001, -5/32, 16/32+0.001}},
-	node_box = {
-		type = "fixed",
-		fixed = {
-			{ -16/32-0.001, -17/32, -3/32, 16/32+0.001, -13/32, 3/32 },
-			{ -3/32, -17/32, -16/32-0.001, 3/32, -13/32, -6/32 },
-			{ -3/32, -13/32, -9/32, 3/32, -6/32, -6/32 },
-			{ -3/32, -9/32, -9/32, 3/32, -6/32, 9/32 },
-			{ -3/32, -13/32, 6/32, 3/32, -6/32, 9/32 },
-			{ -3/32, -17/32, 6/32, 3/32, -13/32, 16/32+0.001 },
-		},
-	},
-	groups = {dig_immediate=3, mesecon=3, mesecon_conductor_craftable=1, not_in_creative_inventory=1},
+	selection_box = {type="fixed", fixed={-16/32, -16/32, -16/32, 16/32, -5/32, 16/32}},
+	groups = {dig_immediate=3, mesecon=3, not_in_creative_inventory=1},
+	sounds = default.node_sound_defaults(),
 	mesecons = {
 		conductor = {
 			states = crossover_states,
 			rules = crossover_get_rules(),
 		}
 	},
+	on_blast = mesecon.on_blastnode,
 })
 
 minetest.register_craft({

mesecons_extrawires/depends.txt

@@ -1,2 +1,3 @@
 default
 mesecons
+screwdriver?

mesecons_extrawires/doc/corner/description.html

@@ -0,0 +1 @@
+Insulated corners are conductors that only conduct between the inputs (also not up or down). When placing they always point to the left in direction of your vision. Like uninsulated wires, they work through unloaded blocks.

mesecons_extrawires/doc/crossing/description.html

@@ -0,0 +1 @@
+Insulated crossing are conductors that conduct two signals between the opposing sides, the signals are insulated to each other. Like uninsulated wires, they work through unloaded blocks.

mesecons_extrawires/doc/mese/description.html

@@ -0,0 +1 @@
+The basic prerequesite for mesecons, can be crafted into wires and other stuff. Have a look at the <a href="http://wiki.minetest.net/Mese">Minetest Wiki</a> for more information. Mese is a conductor. It conducts in all six directions: Up/Down/Left/Right/Forward/Backward. Like horizontal wires, Mese conduction works through unloaded blocks.

mesecons_extrawires/doc/tjunction/description.html

@@ -0,0 +1 @@
+Insulated T-Junctions are conductors that only conduct between the inputs (also not up or down). Like uninsulated wires, they work through unloaded blocks.

mesecons_extrawires/doc/vertical/description.html

@@ -0,0 +1 @@
+Vertical Mesecons only conduct up and down. Plates appear at the ends, at that place they also conduct to the side. Like horizontal wires, they work through unloaded blocks.

mesecons_extrawires/mesewire.lua

@@ -8,12 +8,7 @@ local mesewire_rules =
 	{x = 0, y = 0, z =-1},
 }
 
-minetest.register_node(":default:mese", {
-	description = "Mese Block",
-	tiles = {minetest.registered_nodes["default:mese"].tiles[1]},
-	is_ground_content = true,
-	groups = {cracky=1},
-	sounds = default.node_sound_stone_defaults(),
+minetest.override_item("default:mese", {
 	mesecons = {conductor = {
 		state = mesecon.state.off,
 		onstate = "mesecons_extrawires:mese_powered",
@@ -21,15 +16,22 @@ minetest.register_node(":default:mese", {
 	}}
 })
 
-minetest.register_node("mesecons_extrawires:mese_powered", {
-	tiles = {minetest.registered_nodes["default:mese"].tiles[1].."^[brighten"},
-	is_ground_content = true,
-	groups = {cracky=1, not_in_creative_inventory = 1},
-	sounds = default.node_sound_stone_defaults(),
+-- Copy node definition of powered mese from normal mese
+-- and brighten texture tiles to indicate mese is powered
+local powered_def = mesecon.mergetable(minetest.registered_nodes["default:mese"], {
+	drop = "default:mese",
+	light_source = 5,
 	mesecons = {conductor = {
 		state = mesecon.state.on,
 		offstate = "default:mese",
 		rules = mesewire_rules
 	}},
-	drop = "default:mese"
+	groups = {cracky = 1, not_in_creative_inventory = 1},
+	on_blast = mesecon.on_blastnode,
 })
+
+for i, v in pairs(powered_def.tiles) do
+	powered_def.tiles[i] = v .. "^[brighten"
+end
+
+minetest.register_node("mesecons_extrawires:mese_powered", powered_def)

mesecons_extrawires/tjunction.lua

@@ -1,12 +1,15 @@
+local screwdriver_exists = minetest.global_exists("screwdriver")
+
 local tjunction_nodebox = {
 	type = "fixed",
+	-- ±0.001 is to prevent z-fighting
 	fixed = {{ -16/32-0.001, -17/32, -3/32, 16/32+0.001, -13/32, 3/32 },
 		 { -3/32, -17/32, -16/32+0.001, 3/32, -13/32, -3/32},}
 }
 
 local tjunction_selectionbox = {
 		type = "fixed",
-		fixed = { -16/32-0.001, -18/32, -16/32, 16/32+0.001, -12/32, 7/32 },
+		fixed = { -16/32, -16/32, -16/32, 16/32, -12/32, 7/32 },
 }
 
 local tjunction_get_rules = function (node)
@@ -16,7 +19,7 @@ local tjunction_get_rules = function (node)
 	 {x = 0,  y = 0,  z = -1}}
 
 	for i = 0, node.param2 do
-		rules = mesecon:rotate_rules_left(rules)
+		rules = mesecon.rotate_rules_left(rules)
 	end
 
 	return rules
@@ -34,23 +37,27 @@ minetest.register_node("mesecons_extrawires:tjunction_on", {
 	},
 	paramtype = "light",
 	paramtype2 = "facedir",
+	is_ground_content = false,
 	walkable = false,
 	sunlight_propagates = true,
 	selection_box = tjunction_selectionbox,
 	node_box = tjunction_nodebox,
-	groups = {dig_immediate = 3, mesecon_conductor_craftable=1, not_in_creative_inventory = 1},
+	groups = {dig_immediate = 3, not_in_creative_inventory = 1},
 	drop = "mesecons_extrawires:tjunction_off",
+	sounds = default.node_sound_defaults(),
 	mesecons = {conductor =
 	{
 		state = mesecon.state.on,
 		rules = tjunction_get_rules,
 		offstate = "mesecons_extrawires:tjunction_off"
-	}}
+	}},
+	on_blast = mesecon.on_blastnode,
+	on_rotate = screwdriver_exists and screwdriver.rotate_simple,
 })
 
 minetest.register_node("mesecons_extrawires:tjunction_off", {
 	drawtype = "nodebox",
-	description = "T-junction",
+	description = "Insulated Mesecon T-junction",
 	tiles = {
 		"jeija_insulated_wire_tjunction_tb_off.png",
 		"jeija_insulated_wire_tjunction_tb_off.png^[transformR180",
@@ -61,17 +68,21 @@ minetest.register_node("mesecons_extrawires:tjunction_off", {
 	},
 	paramtype = "light",
 	paramtype2 = "facedir",
+	is_ground_content = false,
 	walkable = false,
 	sunlight_propagates = true,
 	selection_box = tjunction_selectionbox,
 	node_box = tjunction_nodebox,
-	groups = {dig_immediate = 3, mesecon_conductor_craftable=1},
+	groups = {dig_immediate = 3},
+	sounds = default.node_sound_defaults(),
 	mesecons = {conductor =
 	{
 		state = mesecon.state.off,
 		rules = tjunction_get_rules,
 		onstate = "mesecons_extrawires:tjunction_on"
-	}}
+	}},
+	on_blast = mesecon.on_blastnode,
+	on_rotate = screwdriver_exists and screwdriver.rotate_simple,
 })
 
 minetest.register_craft({

mesecons_extrawires/vertical.lua

@@ -18,7 +18,7 @@ local bottom_box = {
 
 local vertical_rules = {
 	{x=0, y=1, z=0},
-	{x=0, y=-1, z=0},
+	{x=0, y=-1, z=0}
 }
 
 local top_rules = {
@@ -26,7 +26,7 @@ local top_rules = {
 	{x=-1,y=0, z=0},
 	{x=0,y=0, z=1},
 	{x=0,y=0, z=-1},
-	{x=0,y=-1, z=0},
+	{x=0,y=-1, z=0}
 }
 
 local bottom_rules = {
@@ -35,167 +35,141 @@ local bottom_rules = {
 	{x=0, y=0, z=1},
 	{x=0, y=0, z=-1},
 	{x=0, y=1, z=0},
+	{x=0, y=2, z=0} -- receive power from pressure plate / detector / ... 2 nodes above
 }
 
 local vertical_updatepos = function (pos)
 	local node = minetest.get_node(pos)
-	if minetest.registered_nodes[node.name] and minetest.registered_nodes[node.name].is_vertical_conductor then
-		local node_above = minetest.get_node(mesecon:addPosRule(pos, vertical_rules[1]))
-		local node_below = minetest.get_node(mesecon:addPosRule(pos, vertical_rules[2]))
-		local namestate = minetest.registered_nodes[node.name].vertical_conductor_state
+	if minetest.registered_nodes[node.name]
+	and minetest.registered_nodes[node.name].is_vertical_conductor then
+		local node_above = minetest.get_node(vector.add(pos, vertical_rules[1]))
+		local node_below = minetest.get_node(vector.add(pos, vertical_rules[2]))
 
-		local above = minetest.registered_nodes[node_above.name] and minetest.registered_nodes[node_above.name].is_vertical_conductor
-		local below = minetest.registered_nodes[node_below.name] and minetest.registered_nodes[node_below.name].is_vertical_conductor
+		local above = minetest.registered_nodes[node_above.name]
+			and minetest.registered_nodes[node_above.name].is_vertical_conductor
+		local below = minetest.registered_nodes[node_below.name]
+			and minetest.registered_nodes[node_below.name].is_vertical_conductor
 
+		mesecon.on_dignode(pos, node)
+
+		-- Always place offstate conductor and let mesecon.on_placenode take care
+		local newname = "mesecons_extrawires:vertical_"
 		if above and below then -- above and below: vertical mesecon
-			minetest.add_node(pos, {name = "mesecons_extrawires:vertical_" .. namestate})
+			newname = newname .. "off"
 		elseif above and not below then -- above only: bottom
-			minetest.add_node(pos, {name = "mesecons_extrawires:vertical_bottom_" .. namestate})
+			newname = newname .. "bottom_off"
 		elseif not above and below then -- below only: top
-			minetest.add_node(pos, {name = "mesecons_extrawires:vertical_top_" .. namestate})
-		else -- no vertical wire above, no vertical wire below: use default wire
-			minetest.add_node(pos, {name = "mesecons_extrawires:vertical_" .. namestate})
+			newname = newname .. "top_off"
+		else -- no vertical wire above, no vertical wire below: use bottom
+			newname = newname .. "bottom_off"
 		end
+
+		minetest.set_node(pos, {name = newname})
+		mesecon.on_placenode(pos, {name = newname})
 	end
 end
 
 local vertical_update = function (pos, node)
 	vertical_updatepos(pos) -- this one
-	vertical_updatepos(mesecon:addPosRule(pos, vertical_rules[1])) -- above
-	vertical_updatepos(mesecon:addPosRule(pos, vertical_rules[2])) -- below
+	vertical_updatepos(vector.add(pos, vertical_rules[1])) -- above
+	vertical_updatepos(vector.add(pos, vertical_rules[2])) -- below
 end
 
 -- Vertical wire
-minetest.register_node("mesecons_extrawires:vertical_on", {
-	description = "Vertical mesecon",
+mesecon.register_node("mesecons_extrawires:vertical", {
+	description = "Vertical Mesecon",
 	drawtype = "nodebox",
-	tiles = {"wires_vertical_on.png"},
 	walkable = false,
 	paramtype = "light",
+	is_ground_content = false,
 	sunlight_propagates = true,
-	groups = {dig_immediate=3, not_in_creative_inventory=1},
 	selection_box = vertical_box,
 	node_box = vertical_box,
 	is_vertical_conductor = true,
-	vertical_conductor_state = "on",
-	mesecons = {conductor = {
-		state = mesecon.state.on,
-		offstate = "mesecons_extrawires:vertical_off",
-		rules = vertical_rules,
-	}},
 	drop = "mesecons_extrawires:vertical_off",
 	after_place_node = vertical_update,
 	after_dig_node = vertical_update,
-})
-
-minetest.register_node("mesecons_extrawires:vertical_off", {
-	description = "Vertical mesecon",
-	drawtype = "nodebox",
-	tiles = {"wires_vertical_off.png"},
-	walkable = false,
-	paramtype = "light",
-	sunlight_propagates = true,
+	sounds = default.node_sound_defaults(),
+},{
+	tiles = {"mesecons_wire_off.png"},
 	groups = {dig_immediate=3},
-	selection_box = vertical_box,
-	node_box = vertical_box,
-	is_vertical_conductor = true,
-	vertical_conductor_state = "off",
 	mesecons = {conductor = {
 		state = mesecon.state.off,
 		onstate = "mesecons_extrawires:vertical_on",
 		rules = vertical_rules,
-	}},
-	after_place_node = vertical_update,
-	after_dig_node = vertical_update,
+	}}
+},{
+	tiles = {"mesecons_wire_on.png"},
+	groups = {dig_immediate=3, not_in_creative_inventory=1},
+	mesecons = {conductor = {
+		state = mesecon.state.on,
+		offstate = "mesecons_extrawires:vertical_off",
+		rules = vertical_rules,
+	}}
 })
 
 -- Vertical wire top
-minetest.register_node("mesecons_extrawires:vertical_top_on", {
+mesecon.register_node("mesecons_extrawires:vertical_top", {
 	description = "Vertical mesecon",
 	drawtype = "nodebox",
-	tiles = {"wires_full_on.png","wires_full_on.png","wires_vertical_on.png"},
 	walkable = false,
 	paramtype = "light",
+	is_ground_content = false,
 	sunlight_propagates = true,
 	groups = {dig_immediate=3, not_in_creative_inventory=1},
 	selection_box = top_box,
 	node_box = top_box,
 	is_vertical_conductor = true,
-	vertical_conductor_state = "on",
-	mesecons = {conductor = {
-		state = mesecon.state.on,
-		offstate = "mesecons_extrawires:vertical_top_off",
-		rules = top_rules,
-	}},
 	drop = "mesecons_extrawires:vertical_off",
 	after_place_node = vertical_update,
 	after_dig_node = vertical_update,
-})
-
-minetest.register_node("mesecons_extrawires:vertical_top_off", {
-	description = "Vertical mesecon",
-	drawtype = "nodebox",
-	tiles = {"wires_full_off.png","wires_full_off.png","wires_vertical_off.png"},
-	walkable = false,
-	paramtype = "light",
-	sunlight_propagates = true,
-	groups = {dig_immediate=3, not_in_creative_inventory=1},
-	selection_box = top_box,
-	node_box = top_box,
-	is_vertical_conductor = true,
-	vertical_conductor_state = "off",
+	sounds = default.node_sound_defaults(),
+},{
+	tiles = {"mesecons_wire_off.png"},
 	mesecons = {conductor = {
 		state = mesecon.state.off,
 		onstate = "mesecons_extrawires:vertical_top_on",
 		rules = top_rules,
-	}},
-	drop = "mesecons_extrawires:vertical_off",
-	after_place_node = vertical_update,
-	after_dig_node = vertical_update,
+	}}
+},{
+	tiles = {"mesecons_wire_on.png"},
+	mesecons = {conductor = {
+		state = mesecon.state.on,
+		offstate = "mesecons_extrawires:vertical_top_off",
+		rules = top_rules,
+	}}
 })
 
 -- Vertical wire bottom
-minetest.register_node("mesecons_extrawires:vertical_bottom_on", {
+mesecon.register_node("mesecons_extrawires:vertical_bottom", {
 	description = "Vertical mesecon",
 	drawtype = "nodebox",
-	tiles = {"wires_full_on.png","wires_full_on.png","wires_vertical_on.png"},
-	walkable = false,
-	paramtype = "light",
-	sunlight_propagates = true,
-	vertical_conductor_state = "on",
-	groups = {dig_immediate = 3, not_in_creative_inventory = 1},
-	selection_box = bottom_box,
-	node_box = bottom_box,
-	mesecons = {conductor = {
-		state = mesecon.state.on,
-		offstate = "mesecons_extrawires:vertical_bottom_off",
-		rules = bottom_rules,
-	}},
-	drop = "mesecons_extrawires:vertical_off",
-	after_place_node = vertical_update,
-	after_dig_node = vertical_update,
-})
-
-minetest.register_node("mesecons_extrawires:vertical_bottom_off", {
-	description = "Vertical mesecon",
-	drawtype = "nodebox",
-	tiles = {"wires_full_off.png","wires_full_off.png","wires_vertical_off.png"},
 	walkable = false,
 	paramtype = "light",
+	is_ground_content = false,
 	sunlight_propagates = true,
 	groups = {dig_immediate = 3, not_in_creative_inventory = 1},
 	selection_box = bottom_box,
 	node_box = bottom_box,
 	is_vertical_conductor = true,
-	vertical_conductor_state = "off",
+	drop = "mesecons_extrawires:vertical_off",
+	after_place_node = vertical_update,
+	after_dig_node = vertical_update,
+	sounds = default.node_sound_defaults(),
+},{
+	tiles = {"mesecons_wire_off.png"},
 	mesecons = {conductor = {
 		state = mesecon.state.off,
 		onstate = "mesecons_extrawires:vertical_bottom_on",
 		rules = bottom_rules,
-	}},
-	drop = "mesecons_extrawires:vertical_off",
-	after_place_node = vertical_update,
-	after_dig_node = vertical_update,
+	}}
+},{
+	tiles = {"mesecons_wire_on.png"},
+	mesecons = {conductor = {
+		state = mesecon.state.on,
+		offstate = "mesecons_extrawires:vertical_bottom_off",
+		rules = bottom_rules,
+	}}
 })
 
 minetest.register_craft({

mesecons_fpga/depends.txt

@@ -0,0 +1,2 @@
+mesecons
+screwdriver?

mesecons_fpga/doc/fpga/description.html

@@ -0,0 +1,6 @@
+FPGAs can be used to chain multiple logic gates together in a compact manner.
+They come with 4 I/O ports and 10 internal registers,
+which can then be connected with each other to form logic circuits.
+They work fine in unloaded blocks.<br />
+Supported gate types: <b>AND</b>, <b>OR</b>, <b>NOT</b>, <b>XOR</b>, <b>NAND</b>, <b>XNOR</b>, <b>Buffer</b> (=)<br />
+I/O ports: <b>A B C D</b>; Registers: numbered <b>0</b> to <b>9</b>

mesecons_fpga/doc/programmer/description.html

@@ -0,0 +1,3 @@
+The FPGA programmer can be used to copy gate configurations from one FPGA to another.<br />
+Shift+Right-Click an FPGA to read its configuration and "remember" it.
+Left-click (punch) FPGAs to write the saved configuration to them.

mesecons_fpga/init.lua

@@ -0,0 +1,420 @@
+local plg = {}
+plg.rules = {}
+
+local lcore = dofile(minetest.get_modpath(minetest.get_current_modname()) .. "/logic.lua")
+dofile(minetest.get_modpath(minetest.get_current_modname()) .. "/tool.lua")(plg)
+
+
+plg.register_nodes = function(template)
+	-- each loop is for one of the 4 IO ports
+	for a = 0, 1 do
+	for b = 0, 1 do
+	for c = 0, 1 do
+	for d = 0, 1 do
+		local ndef = table.copy(template)
+		local nodename = "mesecons_fpga:fpga"
+				.. tostring(d) .. tostring(c) .. tostring(b) .. tostring(a)
+
+		-- build top texture string
+		local texture = "jeija_fpga_top.png"
+		if a == 1 then texture = texture .. "^jeija_microcontroller_LED_A.png" end
+		if b == 1 then texture = texture .. "^jeija_microcontroller_LED_B.png" end
+		if c == 1 then texture = texture .. "^jeija_microcontroller_LED_C.png" end
+		if d == 1 then texture = texture .. "^jeija_microcontroller_LED_D.png" end
+		ndef.tiles[1] = texture
+		ndef.inventory_image = texture
+
+		if (a + b + c + d) > 0 then
+			ndef.groups["not_in_creative_inventory"] = 1
+		end
+
+		-- interaction with mesecons (input / output)
+		local rules_out = {}
+		if a == 1 then table.insert(rules_out, {x = -1, y = 0, z =  0}) end
+		if b == 1 then table.insert(rules_out, {x =  0, y = 0, z =  1}) end
+		if c == 1 then table.insert(rules_out, {x =  1, y = 0, z =  0}) end
+		if d == 1 then table.insert(rules_out, {x =  0, y = 0, z = -1}) end
+		plg.rules[nodename] = rules_out
+
+		local rules_in = {}
+		if a == 0 then table.insert(rules_in, {x = -1, y = 0, z =  0}) end
+		if b == 0 then table.insert(rules_in, {x =  0, y = 0, z =  1}) end
+		if c == 0 then table.insert(rules_in, {x =  1, y = 0, z =  0}) end
+		if d == 0 then table.insert(rules_in, {x =  0, y = 0, z = -1}) end
+		ndef.mesecons.effector.rules = rules_in
+
+		if (a + b + c + d) > 0 then
+			ndef.mesecons.receptor = {
+				state = mesecon.state.on,
+				rules = rules_out,
+			}
+		end
+
+		minetest.register_node(nodename, ndef)
+	end
+	end
+	end
+	end
+end
+
+plg.register_nodes({
+	description = "FPGA",
+	drawtype = "nodebox",
+	tiles = {
+		"", -- replaced later
+		"jeija_microcontroller_bottom.png",
+		"jeija_fpga_sides.png",
+		"jeija_fpga_sides.png",
+		"jeija_fpga_sides.png",
+		"jeija_fpga_sides.png"
+	},
+	inventory_image = "", -- replaced later
+	is_ground_content = false,
+	sunlight_propagates = true,
+	paramtype = "light",
+	walkable = true,
+	groups = {dig_immediate = 2, mesecon = 3, overheat = 1},
+	drop = "mesecons_fpga:fpga0000",
+	selection_box = {
+		type = "fixed",
+		fixed = { -8/16, -8/16, -8/16, 8/16, -5/16, 8/16 },
+	},
+	node_box = {
+		type = "fixed",
+		fixed = {
+			{ -8/16, -8/16, -8/16, 8/16, -7/16, 8/16 }, -- bottom slab
+			{ -5/16, -7/16, -5/16, 5/16, -6/16, 5/16 }, -- circuit board
+			{ -3/16, -6/16, -3/16, 3/16, -5/16, 3/16 }, -- IC
+		}
+	},
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		local is = { {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {} }
+
+		meta:set_string("instr", lcore.serialize(is))
+		meta:set_int("valid", 0)
+		meta:set_string("formspec", plg.to_formspec_string(is))
+		meta:set_string("infotext", "FPGA")
+	end,
+	on_receive_fields = function(pos, formname, fields, sender)
+		if fields.program == nil then return end -- we only care when the user clicks "Program"
+		local meta = minetest.get_meta(pos)
+		local is = plg.from_formspec_fields(fields)
+
+		meta:set_string("instr", lcore.serialize(is))
+		plg.update_formspec(pos, is)
+	end,
+	sounds = default.node_sound_stone_defaults(),
+	mesecons = {
+		effector = {
+			rules = {}, -- replaced later
+			action_change = function(pos, node, rule, newstate)
+				plg.ports_changed(pos, rule, newstate)
+				plg.update(pos)
+			end
+		}
+	},
+	after_dig_node = function(pos, node)
+		mesecon.receptor_off(pos, plg.rules[node.name])
+	end,
+	on_blast = mesecon.on_blastnode,
+	on_rotate = function(pos, node, user, mode)
+		local abcd1 = {"A", "B", "C", "D"}
+		local abcd2 = {A = 1, B = 2, C = 3, D = 4}
+		local ops = {"op1", "op2", "dst"}
+		local dir = 0
+		if mode == screwdriver.ROTATE_FACE then -- clock-wise
+			dir = 1
+			if user and user:is_player() then
+				minetest.chat_send_player(user:get_player_name(),
+						"FPGA ports have been rotated clockwise.")
+			end
+		elseif mode == screwdriver.ROTATE_AXIS then -- counter-clockwise
+			dir = -1
+			if user and user:is_player() then
+				minetest.chat_send_player(user:get_player_name(),
+						"FPGA ports have been rotated counter-clockwise.")
+			end
+		end
+
+		local meta = minetest.get_meta(pos)
+		local instr = lcore.deserialize(meta:get_string("instr"))
+		for i = 1, #instr do
+			for _, op in ipairs(ops) do
+				local o = instr[i][op]
+				if o and o.type == "io" then
+					local num = abcd2[o.port]
+					num = num + dir
+					if num > 4 then num = 1
+					elseif num < 1 then num = 4 end
+					instr[i][op].port = abcd1[num]
+				end
+			end
+		end
+
+		meta:set_string("instr", lcore.serialize(instr))
+		plg.update_formspec(pos, instr)
+		return true
+	end,
+})
+
+
+plg.to_formspec_string = function(is)
+	local function dropdown_op(x, y, name, val)
+		local s = "dropdown[" .. tostring(x) .. "," .. tostring(y) .. ";"
+				.. "0.75,0.5;" .. name .. ";" -- the height seems to be ignored?
+		s = s .. " ,A,B,C,D,0,1,2,3,4,5,6,7,8,9;"
+		if val == nil then
+			s = s .. "0" -- actually selects no field at all
+		elseif val.type == "io" then
+			local mapping = {
+				["A"] = 1,
+				["B"] = 2,
+				["C"] = 3,
+				["D"] = 4,
+			}
+			s = s .. tostring(1 + mapping[val.port])
+		else -- "reg"
+			s = s .. tostring(6 + val.n)
+		end
+		return s .. "]"
+	end
+	local function dropdown_action(x, y, name, val)
+		local s = "dropdown[" .. tostring(x) .. "," .. tostring(y) .. ";"
+				.. "1.125,0.5;" .. name .. ";" -- the height seems to be ignored?
+		s = s .. " , AND,  OR, NOT, XOR,NAND,   =,XNOR;"
+		if val == nil then
+			return s .. "0]" -- actually selects no field at all
+		end
+		local mapping = {
+			["and"] = 1,
+			["or"] = 2,
+			["not"] = 3,
+			["xor"] = 4,
+			["nand"] = 5,
+			["buf"] = 6,
+			["xnor"] = 7,
+		}
+		return s .. tostring(1 + mapping[val]) .. "]"
+	end
+	local s = "size[9,9]"..
+		"label[3.4,-0.15;FPGA gate configuration]"..
+		"button_exit[7,7.5;2,2.5;program;Program]"..
+		"box[4.2,0.5;0.03,7;#ffffff]"..
+		"label[0.25,0.25;op. 1]"..
+		"label[1.0,0.25;gate type]"..
+		"label[2.125,0.25;op. 2]"..
+		"label[3.15,0.25;dest]"..
+		"label[4.5,0.25;op. 1]"..
+		"label[5.25,0.25;gate type]"..
+		"label[6.375,0.25;op. 2]"..
+		"label[7.4,0.25;dest]"
+	local x = 1 - 0.75
+	local y = 1 - 0.25
+	for i = 1, 14 do
+		local cur = is[i]
+		s = s .. dropdown_op    (x      , y, tostring(i).."op1", cur.op1)
+		s = s .. dropdown_action(x+0.75 , y, tostring(i).."act", cur.action)
+		s = s .. dropdown_op    (x+1.875, y, tostring(i).."op2", cur.op2)
+		s = s .. "label[" .. tostring(x+2.625) .. "," .. tostring(y+0.1) .. "; ->]"
+		s = s .. dropdown_op    (x+2.9  , y, tostring(i).."dst", cur.dst)
+		y = y + 1
+
+		if i == 7 then
+			x = 4.5
+			y = 1 - 0.25
+		end
+	end
+	return s
+end
+
+plg.from_formspec_fields = function(fields)
+	local function read_op(s)
+		if s == nil or s == " " then
+			return nil
+		elseif s == "A" or s == "B" or s == "C" or s == "D" then
+			return {type = "io", port = s}
+		else
+			return {type = "reg", n = tonumber(s)}
+		end
+	end
+	local function read_action(s)
+		if s == nil or s == " " then
+			return nil
+		end
+		local mapping = {
+			["AND"] = "and",
+			["OR"] = "or",
+			["NOT"] = "not",
+			["XOR"] = "xor",
+			["NAND"] = "nand",
+			["="] = "buf",
+			["XNOR"] = "xnor",
+		}
+		s = s:gsub("^%s*", "") -- remove leading spaces
+		return mapping[s]
+	end
+	local is = {}
+	for i = 1, 14 do
+		local cur = {}
+		cur.op1 = read_op(fields[tonumber(i) .. "op1"])
+		cur.action = read_action(fields[tonumber(i) .. "act"])
+		cur.op2 = read_op(fields[tonumber(i) .. "op2"])
+		cur.dst = read_op(fields[tonumber(i) .. "dst"])
+		is[#is + 1] = cur
+	end
+	return is
+end
+
+plg.update_formspec = function(pos, is)
+	if type(is) == "string" then -- serialized string
+		is = lcore.deserialize(is)
+	end
+	local meta = minetest.get_meta(pos)
+	local form = plg.to_formspec_string(is)
+
+	local err = lcore.validate(is)
+	if err == nil then
+		meta:set_int("valid", 1)
+		meta:set_string("infotext", "FPGA (functional)")
+	else
+		meta:set_int("valid", 0)
+		meta:set_string("infotext", "FPGA")
+		local fmsg = minetest.colorize("#ff0000", minetest.formspec_escape(err.msg))
+		form = form .. plg.red_box_around(err.i) ..
+			"label[0.25,8.25;The gate configuration is erroneous in the marked area:]"..
+			"label[0.25,8.5;" .. fmsg .. "]"
+	end
+
+	meta:set_string("formspec", form)
+
+	-- reset ports and run programmed logic
+	plg.setports(pos, false, false, false, false)
+	plg.update(pos)
+end
+
+plg.red_box_around = function(i)
+	local x, y
+	if i > 7 then
+		x = 4.5
+		y = 0.75 + (i - 8)
+	else
+		x = 0.25
+		y = 0.75 + (i - 1)
+	end
+	return string.format("box[%f,%f;3.8,0.8;#ff0000]", x-0.1, y-0.05)
+end
+
+
+plg.update = function(pos)
+	local meta = minetest.get_meta(pos)
+	if meta:get_int("valid") ~= 1 then
+		return
+	elseif mesecon.do_overheat(pos) then
+		plg.setports(pos, false, false, false, false)
+		meta:set_int("valid", 0)
+		meta:set_string("infotext", "FPGA (overheated)")
+		return
+	end
+
+	local is = lcore.deserialize(meta:get_string("instr"))
+	local A, B, C, D = plg.getports(pos)
+	A, B, C, D = lcore.interpret(is, A, B, C, D)
+	plg.setports(pos, A, B, C, D)
+end
+
+plg.ports_changed = function(pos, rule, newstate)
+	if rule == nil then return end
+	local meta = minetest.get_meta(pos)
+	local states
+
+	local s = meta:get_string("portstates")
+	if s == nil then
+		states = {false, false, false, false}
+	else
+		states = {
+			s:sub(1, 1) == "1",
+			s:sub(2, 2) == "1",
+			s:sub(3, 3) == "1",
+			s:sub(4, 4) == "1",
+		}
+	end
+
+	-- trick to transform rules (see register_node) into port number
+	local portno = ({4, 1, nil, 3, 2})[3 + rule.x + 2*rule.z]
+	states[portno] = (newstate == "on")
+
+	meta:set_string("portstates",
+			(states[1] and "1" or "0") .. (states[2] and "1" or "0") ..
+			(states[3] and "1" or "0") .. (states[4] and "1" or "0")
+	)
+end
+
+plg.getports = function(pos) -- gets merged states of INPUT & OUTPUT
+	local sin, sout
+
+	local s = minetest.get_meta(pos):get_string("portstates")
+	if s == nil then
+		sin = {false, false, false, false}
+	else
+		sin = {
+			s:sub(1, 1) == "1",
+			s:sub(2, 2) == "1",
+			s:sub(3, 3) == "1",
+			s:sub(4, 4) == "1",
+		}
+	end
+
+	local name = minetest.get_node(pos).name
+	assert(name:find("mesecons_fpga:fpga") == 1)
+	local off = #"mesecons_fpga:fpga"
+	sout = {
+		name:sub(off+4, off+4) == "1",
+		name:sub(off+3, off+3) == "1",
+		name:sub(off+2, off+2) == "1",
+		name:sub(off+1, off+1) == "1",
+	}
+
+	return unpack({
+		sin[1] or sout[1],
+		sin[2] or sout[2],
+		sin[3] or sout[3],
+		sin[4] or sout[4],
+	})
+end
+
+plg.setports = function(pos, A, B, C, D) -- sets states of OUTPUT
+	local base = "mesecons_fpga:fpga"
+
+	local name = base
+			.. (D and "1" or "0") .. (C and "1" or "0")
+			.. (B and "1" or "0") .. (A and "1" or "0")
+	minetest.swap_node(pos, {name = name, param2 = minetest.get_node(pos).param2})
+
+	if A ~= nil then
+		local ru = plg.rules[base .. "0001"]
+		if A then mesecon.receptor_on(pos, ru) else mesecon.receptor_off(pos, ru) end
+	end
+	if B ~= nil then
+		local ru = plg.rules[base .. "0010"]
+		if B then mesecon.receptor_on(pos, ru) else mesecon.receptor_off(pos, ru) end
+	end
+	if C ~= nil then
+		local ru = plg.rules[base .. "0100"]
+		if C then mesecon.receptor_on(pos, ru) else mesecon.receptor_off(pos, ru) end
+	end
+	if D ~= nil then
+		local ru = plg.rules[base .. "1000"]
+		if D then mesecon.receptor_on(pos, ru) else mesecon.receptor_off(pos, ru) end
+	end
+end
+
+
+minetest.register_craft({
+	output = "mesecons_fpga:fpga0000 2",
+	recipe = {
+		{'group:mesecon_conductor_craftable', 'group:mesecon_conductor_craftable'},
+		{'mesecons_materials:silicon', 'mesecons_materials:silicon'},
+		{'group:mesecon_conductor_craftable', 'group:mesecon_conductor_craftable'},
+	}
+})

mesecons_fpga/logic.lua

@@ -0,0 +1,210 @@
+local lg = {}
+
+-- (de)serialize
+lg.serialize = function(t)
+	local function _op(t)
+		if t == nil then
+			return " "
+		elseif t.type == "io" then
+			return t.port
+		else -- t.type == "reg"
+			return tostring(t.n)
+		end
+	end
+	local function _action(s)
+		if s == nil then
+			return " "
+		end
+		local mapping = {
+			["and"] = "&",
+			["or"] = "|",
+			["not"] = "~",
+			["xor"] = "^",
+			["nand"] = "?", --dunno
+			["buf"] = "_",
+			["xnor"] = "=",
+		}
+		return mapping[s]
+	end
+
+	local s = ""
+	for i = 1, 14 do
+		local cur = t[i]
+		if next(cur) ~= nil then
+			s = s .. _op(cur.op1) .. _action(cur.action) .. _op(cur.op2) .. _op(cur.dst)
+		end
+		s = s .. "/"
+	end
+	return s
+end
+
+lg.deserialize = function(s)
+	local function _op(c)
+		if c == "A" or c == "B" or c == "C" or c == "D" then
+			return {type = "io", port = c}
+		elseif c == " " then
+			return nil
+		else
+			return {type = "reg", n = tonumber(c)}
+		end
+	end
+	local function _action(c)
+		local mapping = {
+			["&"] = "and",
+			["|"] = "or",
+			["~"] = "not",
+			["^"] = "xor",
+			["?"] = "nand",
+			["_"] = "buf",
+			["="] = "xnor",
+			[" "] = nil,
+		}
+		return mapping[c]
+	end
+
+	local ret = {}
+	for part in s:gmatch("(.-)/") do
+		local parsed
+		if part == "" then
+			parsed = {}
+		else
+			parsed = {
+				action = _action( part:sub(2,2) ),
+				op1 = _op( part:sub(1,1) ),
+				op2 = _op( part:sub(3,3) ),
+				dst = _op( part:sub(4,4) ),
+			}
+		end
+		ret[#ret + 1] = parsed
+	end
+	-- More than 14 instructions (write to all 10 regs + 4 outputs)
+	-- will not pass the write-once requirement of the validator
+	assert(#ret == 14)
+	return ret
+end
+
+-- validation
+lg.validate_single = function(t, i)
+	local function is_reg_written_to(t, n, max)
+		for i = 1, max-1 do
+			if next(t[i]) ~= nil
+					and t[i].dst and t[i].dst.type == "reg"
+					and t[i].dst.n == n then
+				return true
+			end
+		end
+		return false
+	end
+	local function compare_op(t1, t2, allow_same_io)
+		if t1 == nil or t2 == nil then
+			return false
+		elseif t1.type ~= t2.type then
+			return false
+		end
+		if t1.type == "reg" and t1.n == t2.n then
+			return true
+		elseif t1.type == "io" and t1.port == t2.port then
+			return not allow_same_io
+		end
+		return false
+	end
+	local elem = t[i]
+	-- check for completeness
+	if elem.action == nil then
+		return {i = i, msg = "Gate type required"}
+	elseif elem.action == "not" or elem.action == "buf" then
+		if elem.op1 ~= nil or elem.op2 == nil or elem.dst == nil then
+			return {i = i, msg = "Second operand (only) and destination required"}
+		end
+	else
+		if elem.op1 == nil or elem.op2 == nil or elem.dst == nil then
+			return {i = i, msg = "Operands and destination required"}
+		end
+	end
+	-- check whether operands/destination are identical
+	if compare_op(elem.op1, elem.op2) then
+		return {i = i, msg = "Operands cannot be identical"}
+	end
+	if compare_op(elem.op1, elem.dst, true) or compare_op(elem.op2, elem.dst, true) then
+		return {i = i, msg = "Destination and operands must be different"}
+	end
+	-- check whether operands point to defined registers
+	if elem.op1 ~= nil and elem.op1.type == "reg"
+			and not is_reg_written_to(t, elem.op1.n, i) then
+		return {i = i, msg = "First operand is undefined register"}
+	end
+	if elem.op2.type == "reg" and not is_reg_written_to(t, elem.op2.n, i) then
+		return {i = i, msg = "Second operand is undefined register"}
+	end
+	-- check whether destination points to undefined register
+	if elem.dst.type == "reg" and is_reg_written_to(t, elem.dst.n, i) then
+		return {i = i, msg = "Destination is already used register"}
+	end
+
+	return nil
+end
+
+lg.validate = function(t)
+	for i = 1, 14 do
+		if next(t[i]) ~= nil then
+			local r = lg.validate_single(t, i)
+			if r ~= nil then
+				return r
+			end
+		end
+	end
+	return nil
+end
+
+-- interpreter
+lg.interpret = function(t, a, b, c, d)
+	local function _action(s, v1, v2)
+		if s == "and" then
+			return v1 and v2
+		elseif s == "or" then
+			return v1 or v2
+		elseif s == "not" then
+			return not v2
+		elseif s == "xor" then
+			return v1 ~= v2
+		elseif s == "nand" then
+			return not (v1 and v2)
+		elseif s == "buf" then
+			return v2
+		else -- s == "xnor"
+			return v1 == v2
+		end
+	end
+	local function _op(t, regs, io_in)
+		if t.type == "reg" then
+			return regs[t.n]
+		else -- t.type == "io"
+			return io_in[t.port]
+		end
+	end
+
+	local io_in = {A=a, B=b, C=c, D=d}
+	local regs = {}
+	local io_out = {}
+	for i = 1, 14 do
+		local cur = t[i]
+		if next(cur) ~= nil then
+			local v1, v2
+			if cur.op1 ~= nil then
+				v1 = _op(cur.op1, regs, io_in)
+			end
+			v2 = _op(cur.op2, regs, io_in)
+
+			local result = _action(cur.action, v1, v2)
+
+			if cur.dst.type == "reg" then
+				regs[cur.dst.n] = result
+			else -- cur.dst.type == "io"
+				io_out[cur.dst.port] = result
+			end
+		end
+	end
+	return io_out.A, io_out.B, io_out.C, io_out.D
+end
+
+return lg

mesecons_fpga/tool.lua

@@ -0,0 +1,62 @@
+return function(plg)
+
+
+minetest.register_tool("mesecons_fpga:programmer", {
+	description = "FPGA Programmer",
+	inventory_image = "jeija_fpga_programmer.png",
+	stack_max = 1,
+	on_place = function(itemstack, placer, pointed_thing)
+		if pointed_thing.type ~= "node" then
+			return itemstack
+		end
+
+		local pos = pointed_thing.under
+		if minetest.get_node(pos).name:find("mesecons_fpga:fpga") ~= 1 then
+			return itemstack
+		end
+
+		local meta = minetest.get_meta(pos)
+		if meta:get_string("instr") == "//////////////" then
+			minetest.chat_send_player(placer:get_player_name(), "This FPGA is unprogrammed.")
+			return itemstack
+		end
+		itemstack:set_metadata(meta:get_string("instr"))
+		minetest.chat_send_player(placer:get_player_name(), "FPGA gate configuration was successfully copied!")
+		
+		return itemstack
+	end,
+	on_use = function(itemstack, user, pointed_thing)
+		if pointed_thing.type ~= "node" then
+			return itemstack
+		end
+
+		local pos = pointed_thing.under
+		if minetest.get_node(pos).name:find("mesecons_fpga:fpga") ~= 1 then
+			return itemstack
+		end
+
+		local imeta = itemstack:get_metadata()
+		if imeta == "" then
+			minetest.chat_send_player(user:get_player_name(), "Use shift+right-click to copy a gate configuration first.")
+			return itemstack
+		end
+
+		local meta = minetest.get_meta(pos)
+		meta:set_string("instr", imeta)
+		plg.update_formspec(pos, imeta)
+		minetest.chat_send_player(user:get_player_name(), "Gate configuration was successfully written to FPGA!")
+
+		return itemstack
+	end
+})
+
+minetest.register_craft({
+	output = "mesecons_fpga:programmer",
+	recipe = {
+		{'group:mesecon_conductor_craftable'},
+		{'mesecons_materials:silicon'},
+	}
+})
+
+
+end

mesecons_gates/doc/and/description.html

@@ -0,0 +1,2 @@
+AND gates power their output if both inputs (from left and right) are powered.
+They work in unloaded blocks.