remove external depends

Make sure node is registered before attempting to access the vports

.github/workflows/check-release.yml

@@ -0,0 +1,15 @@
+on: [push, pull_request]
+name: Check & Release
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@main
+    - name: apt
+      run: sudo apt-get install -y luarocks
+    - name: luacheck install
+      run: luarocks install --local luacheck
+    - name: luacheck run
+      run: $HOME/.luarocks/bin/luacheck ./

.gitignore

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

.luacheckrc

@@ -0,0 +1,36 @@
+std = "lua51c"
+
+ignore = {
+	"21/_+", -- Unused variable, except "_", "__", etc.
+	"213", -- Unused loop variable
+	"421", -- Shadowing a local variable
+	"422", -- Shadowing an argument
+	"423", -- Shadowing a loop variable
+	"431", -- Shadowing an upvalue
+	"432", -- Shadowing an upvalue argument
+	"433", -- Shadowing an upvalue loop variable
+	"542", -- Empty if branch
+}
+
+max_line_length = 200
+
+read_globals = {
+	"default",
+	"digiline",
+	"doors",
+	"dump",
+	"jit",
+	"minetest",
+	"screwdriver",
+	"string.split",
+	"table.copy",
+	"table.insert_all",
+	"vector",
+	"VoxelArea",
+}
+
+globals = {"mesecon"}
+
+files["mesecons/actionqueue.lua"] = {
+	globals = {"minetest.registered_globalsteps"},
+}

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/

LICENSE.txt

@@ -1,6 +1,12 @@
 The LGPLv3 applies to all code in this project.
 The CC-BY-SA-3.0 license applies to textures and any other content in this project which is not source code.
 
+The file mesecons_detector/textures/mesecons_detector_side.png is an unmodified copy of
+"default_steel_block.png" by Jean-Patrick Guerrero <https://github.com/kilbith>, which can be found at
+<https://github.com/minetest/minetest_game/blob/9528c0f8b93d6934930e99c3c116df275fb0e4bc/mods/default/textures/default_steel_block.png>.
+"default_steel_block.png" is licensed under a CC BY-SA 3.0 license. This license can be found later in this document, and can also be found at
+<https://creativecommons.org/licenses/by-sa/3.0/>. The artwork is reportedly copyright (C) 2010-2018 kilbith.
+
 =================================================================
 
 GNU LESSER GENERAL PUBLIC LICENSE

README.md

@@ -12,9 +12,9 @@ MESECONS by Jeija and contributors
 
 Mezzee-what?
 ------------
-[Mesecons](http://mesecons.net/)! They're yellow, they're conductive, and they'll add a whole new dimension to Minetest's gameplay.
+[Mesecons](https://mesecons.net/)! They're yellow, they're conductive, and they'll add a whole new dimension to Minetest's gameplay.
 
-Mesecons is a mod for [Minetest](http://minetest.net/) that implements a ton of items related to digital circuitry, such as wires, buttons, lights, and even programmable controllers. Among other things, there are also pistons, solar panels, pressure plates, and note blocks.
+Mesecons is a mod for [Minetest](https://www.minetest.net/) that implements a ton of items related to digital circuitry, such as wires, buttons, lights, and even programmable controllers. Among other things, there are also pistons, solar panels, pressure plates, and note blocks.
 
 Mesecons has a similar goal to Redstone in Minecraft, but works in its own way, with different rules and mechanics.
 
@@ -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.                |
@@ -71,8 +74,10 @@ There are also a whole bunch of other people helping with everything from code t
 
 Alright, how can I use it?
 --------------------------
-All textures in this project are licensed under the CC-BY-SA 3.0 (Creative Commons Attribution-ShareAlike 3.0 Generic). That means you can distribute and remix them as much as you want to, under the condition that you give credit to the authors and the project, and that if you remix and release them, they must be under the same or similar license to this one.
+All textures in this project are licensed under the CC-BY-SA 3.0 (Creative Commons Attribution-ShareAlike 3.0 Generic).
+That means you can distribute and remix them as much as you want to, under the condition that you give credit to the authors and the project, and that if you remix and release them, they must be under the same or similar license to this one.
 
-All code in this project is licensed under the LGPL version 3 or later. That means you have unlimited freedom to distribute and modify the work however you see fit, provided that if you decide to distribute it or any modified versions of it, you must also use the same license. The LGPL also grants the additional freedom to write extensions for the software and distribute them without the extensions being subject to the terms of the LGPL, although the software itself retains its license.
+All code in this project is licensed under the LGPL version 3.
+That means you have unlimited freedom to distribute and modify the work however you see fit, provided that if you decide to distribute it or any modified versions of it, you must also use the same license. The LGPL also grants the additional freedom to write extensions for the software and distribute them without the extensions being subject to the terms of the LGPL, although the software itself retains its license.
 
 No warranty is provided, express or implied, for any part of the project.

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

mesecons/depends.txt

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

mesecons/fifo_queue.lua

@@ -0,0 +1,62 @@
+
+-- a simple first-in-first-out queue
+-- very similar to the one in https://github.com/minetest/minetest/pull/7683
+
+local fifo_queue = {}
+
+local metatable = {__index = fifo_queue}
+
+-- creates a new empty queue
+function fifo_queue.new()
+	local q = {n_in = 0, n_out = 0, i_out = 1, buf_in = {}, buf_out = {}}
+	setmetatable(q, metatable)
+	return q
+end
+
+-- adds an element to the queue
+function fifo_queue.add(self, v)
+	local n = self.n_in + 1
+	self.n_in = n
+	self.buf_in[n] = v
+end
+
+-- removes and returns the next element, or nil of empty
+function fifo_queue.take(self)
+	local i_out = self.i_out
+	if i_out <= self.n_out then
+		local v = self.buf_out[i_out]
+		self.i_out = i_out + 1
+		self.buf_out[i_out] = true
+		return v
+	end
+
+	-- buf_out is empty, try to swap
+	self.i_out = 1
+	self.n_out = 0
+	if self.n_in == 0 then
+		return nil -- empty
+	end
+
+	-- swap
+	self.n_out = self.n_in
+	self.n_in = 0
+	self.buf_out, self.buf_in = self.buf_in, self.buf_out
+
+	local v = self.buf_out[1]
+	self.i_out = 2
+	self.buf_out[1] = true
+	return v
+end
+
+-- returns whether the queue is empty
+function fifo_queue.is_empty(self)
+	return self.n_out == self.i_out + 1 and self.n_in == 0
+end
+
+-- returns stuff for iteration in a for loop, like pairs
+-- adding new elements while iterating is no problem
+function fifo_queue.iter(self)
+	return fifo_queue.take, self, nil
+end
+
+return fifo_queue

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
 --
 --
 --
@@ -30,7 +30,7 @@
 --		action_change = function
 --		rules = rules/get_rules
 --	},
---	conductor = 
+--	conductor =
 --	{
 --		state = mesecon.state.on/off
 --		offstate = opposite state (for state = on only)
@@ -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
-		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)
+mesecon.queue:add_function("receptor_off", function (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)
+			mesecon.vm_begin()
+			mesecon.changesignal(np, minetest.get_node(np), rulename, mesecon.state.off, 2)
+
+			-- 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:changesignal(np, minetest.get_node(np), rulename, mesecon.state.off)
+				mesecon.vm_abort()
 			end
 		end
 	end
-end
+end)
 
-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"}
-	else
-		mesecon:receptor_off_i(pos, rules)
-	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/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)
-end
+-- 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().."/mesecon_forceloaded")

mesecons/mod.conf

@@ -0,0 +1,3 @@
+name = mesecons
+# default is an optional dependency as some mods may expect it as a transitory
+# dependency when they depend on mesecons.

mesecons/oldwires.lua

@@ -4,14 +4,14 @@ 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",
 		fixed = {-0.5, -0.5, -0.5, 0.5, -0.45, 0.5},
 	},
 	groups = {dig_immediate=3, mesecon=1, mesecon_conductor_craftable=1},
-    	description="Mesecons",
+	description="Mesecons",
 	mesecons = {conductor={
 		state = mesecon.state.off,
 		onstate = "mesecons:mesecon_on"
@@ -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.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.floor = mesecon.merge_rule_sets(mesecon.rules.default, {{x = 0, y = -1, z = 0}})
+
+mesecon.rules.pplate = mesecon.merge_rule_sets(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.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.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,139 @@
-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))
-		else
-			mesecon:changesignal(pos, node, mesecon:effector_get_rules(node), "on")
-			mesecon:activate(pos, node)
+-- Dig and place services
+
+mesecon.on_placenode = function(pos, node)
+	mesecon.execute_autoconnect_hooks_now(pos, node)
+	node = minetest.get_node(pos) -- Update the node in case it was just changed.
+
+	-- 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 conductor = mesecon.get_conductor(node.name)
+		if conductor.state ~= mesecon.state.off then
+			-- Turn the conductor off.
+			node.name = conductor.offstate or conductor.states[1]
+			minetest.swap_node(pos, node)
+		end
+		local sources = mesecon.is_powered(pos)
+		if sources then
+			mesecon.vm_begin()
+			for _, s in ipairs(sources) do
+				local rule = vector.subtract(s, pos)
+				mesecon.turnon(pos, rule)
+			end
+			mesecon.vm_commit()
+		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
+			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)
+	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
+-- SETTINGS
+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,101 @@
-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)
---]]
+-- An on_rotate callback for mesecons components.
+function mesecon.on_rotate(pos, node, _, _, new_param2)
+	local new_node = {name = node.name, param1 = node.param1, param2 = new_param2}
+	minetest.swap_node(pos, new_node)
+	mesecon.on_dignode(pos, node)
+	mesecon.on_placenode(pos, new_node)
+	minetest.check_for_falling(pos)
+	return true
+end
 
-function mesecon:flattenrules(allrules)
+-- An on_rotate callback for components which stay horizontal.
+function mesecon.on_rotate_horiz(pos, node, user, mode, new_param2)
+	if not minetest.global_exists("screwdriver") or mode ~= screwdriver.ROTATE_FACE then
+		return false
+	end
+	return mesecon.on_rotate(pos, node, user, mode, new_param2)
+end
+
+-- 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.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
+
+-- Returns a rules getter function that returns different rules depending on the node's horizontal rotation.
+-- If param2 % 4 == 0, then the rules returned by the getter are a copy of base_rules.
+function mesecon.horiz_rules_getter(base_rules)
+	local rotations = {mesecon.tablecopy(base_rules)}
+	for i = 2, 4 do
+		local right_rules = rotations[i - 1]
+		if not right_rules[1] or right_rules[1].x then
+			-- flat rules
+			rotations[i] = mesecon.rotate_rules_left(right_rules)
+		else
+			-- not flat
+			rotations[i] = {}
+			for j, rules in ipairs(right_rules) do
+				rotations[i][j] = mesecon.rotate_rules_left(rules)
+			end
+		end
+	end
+	return function(node)
+		return rotations[node.param2 % 4 + 1]
+	end
+end
+
+function mesecon.flattenrules(allrules)
 --[[
 	{
 		{
@@ -53,7 +130,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 +139,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 +179,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)
-		local x, y = math.floor(n / 2), n % 2
-		if (n > 1) then
-			return dec2bin(x)..y
-		else
-			return ""..y
-		end
+function mesecon.dec2bin(n)
+	local x, y = math.floor(n / 2), n % 2
+	if (n > 1) then
+		return mesecon.dec2bin(x)..y
+	else
+		return ""..y
 	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,56 +197,327 @@ 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)
+	local len = binary:len()
+	if bit > len then return false end
+	local c = 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}
+function mesecon.tablecopy(obj) -- deep copy
+	if type(obj) == "table" then
+		return table.copy(obj)
+	end
+	return obj
 end
 
-function mesecon:cmpPos(p1, p2)
-	return (p1.x == p2.x and p1.y == p2.y and p1.z == p2.z)
-end
+-- Returns whether two values are equal.
+-- In tables, keys are compared for identity but values are compared recursively.
+-- There is no protection from infinite recursion.
+function mesecon.cmpAny(t1, t2)
+	if type(t1) ~= type(t2) then return false end
+	if type(t1) ~= "table" then return t1 == t2 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
-	local newtable = {}
-
-	for idx, item in pairs(table) do
-		if type(item) == "table" then
-			newtable[idx] = mesecon:tablecopy(item)
-		else
-			newtable[idx] = item
-		end
+	-- Check that for each key of `t1` both tables have the same value
+	for i, e in pairs(t1) do
+		if not mesecon.cmpAny(e, t2[i]) then return false end
 	end
 
-	return newtable
+	-- Check that all keys of `t2` are also keys of `t1` so were checked in the previous loop
+	for i, _ in pairs(t2) do
+		if t1[i] == nil then return false end
+	end
+
+	return true
+end
+
+-- Deprecated. Use `merge_tables` or `merge_rule_sets` as appropriate.
+function mesecon.mergetable(source, dest)
+	minetest.log("warning", debug.traceback("Deprecated call to mesecon.mergetable"))
+	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
+
+-- Merges several rule sets in one. Order may not be preserved. Nil arguments
+-- are ignored.
+-- The rule sets must be of the same kind (either all single-level or all two-level).
+-- The function may be changed to normalize the resulting set in some way.
+function mesecon.merge_rule_sets(...)
+	local rval = {}
+	for _, t in pairs({...}) do -- ignores nils automatically
+		table.insert_all(rval, mesecon.tablecopy(t))
+	end
+	return rval
+end
+
+-- Merges two tables, with entries from `replacements` taking precedence over
+-- those from `base`. Returns the new table.
+-- Values are deep-copied from either table, keys are referenced.
+-- Numerical indices aren’t handled specially.
+function mesecon.merge_tables(base, replacements)
+	local ret = mesecon.tablecopy(replacements) -- these are never overriden so have to be copied in any case
+	for k, v in pairs(base) do
+		if ret[k] == nil then -- it could be `false`
+			ret[k] = mesecon.tablecopy(v)
+		end
+	end
+	return ret
+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.merge_tables(spec_common, spec_on);
+	spec_off = mesecon.merge_tables(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.."/"..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.."/"..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
+-- “dirty” → true if data has been modified
+--
+-- Nil if no VM-based transaction is in progress.
+local vm_cache = nil
+
+-- Cache from node position hashes to nodes (represented as tables).
+local vm_node_cache = nil
+
+-- Whether the current transaction will need a light update afterward.
+local vm_update_light = false
+
+-- 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 = {}
+	vm_node_cache = {}
+	vm_update_light = false
+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:write_to_map(vm_update_light)
+			vm:update_map()
+		end
+	end
+	vm_cache = nil
+	vm_node_cache = nil
+end
+
+-- Finishes a VoxelManipulator-based transaction, freeing the VMs and throwing
+-- away any modified areas.
+function mesecon.vm_abort()
+	vm_cache = nil
+	vm_node_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
+		tbl = {vm = minetest.get_voxel_manip(pos, pos), 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 hash = minetest.hash_node_position(pos)
+	local node = vm_node_cache[hash]
+	if not node then
+		node = vm_get_or_create_entry(pos).vm:get_node_at(pos)
+		vm_node_cache[hash] = node
+	end
+	return node.name ~= "ignore" and {name = node.name, param1 = node.param1, param2 = node.param2} or nil
+end
+
+-- Sets a node’s name during a VoxelManipulator-based transaction.
+--
+-- Existing param1, param2, and metadata are left alone.
+--
+-- The swap will necessitate a light update unless update_light equals false.
+function mesecon.vm_swap_node(pos, name, update_light)
+	-- If one node needs a light update, all VMs should use light updates to
+	-- prevent newly calculated light from being overwritten by other VMs.
+	vm_update_light = vm_update_light or update_light ~= false
+
+	local tbl = vm_get_or_create_entry(pos)
+	local hash = minetest.hash_node_position(pos)
+	local node = vm_node_cache[hash]
+	if not node then
+		node = tbl.vm:get_node_at(pos)
+		vm_node_cache[hash] = node
+	end
+	node.name = name
+	tbl.vm:set_node_at(pos, node)
+	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.
+--
+-- The swap will necessitate a light update unless update_light equals false.
+function mesecon.swap_node_force(pos, name, update_light)
+	if vm_cache then
+		return mesecon.vm_swap_node(pos, name, update_light)
+	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_alias/depends.txt

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

mesecons_alias/mod.conf

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

mesecons_blinkyplant/depends.txt

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

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,51 @@
 -- 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},
-    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",
-	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)
+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
 
-minetest.register_craft({
-	output = "mesecons_blinkyplant:blinky_plant_off 1",
-	recipe = {
-	{"","group:mesecon_conductor_craftable",""},
-	{"","group:mesecon_conductor_craftable",""},
-	{"default:sapling","default:sapling","default:sapling"},
-	}
-})
+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
 
-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)
+mesecon.register_node("mesecons_blinkyplant:blinky_plant", {
+	description="Blinky Plant",
+	drawtype = "plantlike",
+	inventory_image = "jeija_blinky_plant_off.png",
+	paramtype = "light",
+	is_ground_content = false,
+	walkable = false,
+	sounds = mesecon.node_sound.leaves,
+	selection_box = {
+		type = "fixed",
+		fixed = {-0.3, -0.5, -0.3, 0.3, -0.5+0.7, 0.3},
+	},
+	on_timer = on_timer,
+	on_rightclick = function(pos, _, clicker)
+		if minetest.is_protected(pos, clicker and clicker:get_player_name() or "") then
+			return
+		end
+
+		toggle_timer(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,
-})
+	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 }}
+})

mesecons_blinkyplant/mod.conf

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

mesecons_button/depends.txt

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

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,35 +4,41 @@
 
 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 }, true)
+	local rules = mesecon.rules.buttonlike_get(node)
+	mesecon.receptor_off(pos, rules)
 end
 
+local use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "opaque" or nil
+
 minetest.register_node("mesecons_button:button_off", {
 	drawtype = "nodebox",
 	tiles = {
-	"jeija_wall_button_sides.png",	
-	"jeija_wall_button_sides.png",
-	"jeija_wall_button_sides.png",
-	"jeija_wall_button_sides.png",
-	"jeija_wall_button_sides.png",
-	"jeija_wall_button_off.png"
+		"jeija_wall_button_sides.png",
+		"jeija_wall_button_sides.png",
+		"jeija_wall_button_sides.png",
+		"jeija_wall_button_sides.png",
+		"jeija_wall_button_sides.png",
+		"jeija_wall_button_off.png"
 	},
+	use_texture_alpha = use_texture_alpha,
 	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",
 		fixed = { -6/16, -6/16, 5/16, 6/16, 6/16, 8/16 }
 	},
 	node_box = {
-		type = "fixed",	
+		type = "fixed",
 		fixed = {
 		{ -6/16, -6/16, 6/16, 6/16, 6/16, 8/16 },	-- the thin plate behind the button
 		{ -4/16, -2/16, 4/16, 4/16, 2/16, 6/16 }	-- the button itself
@@ -40,17 +46,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))
-		minetest.sound_play("mesecons_button_push", {pos=pos})
-		minetest.after(1, mesecon.button_turnoff, pos)
+		mesecon.receptor_on(pos, mesecon.rules.buttonlike_get(node))
+		minetest.sound_play("mesecons_button_push", { pos = pos }, true)
+		minetest.get_node_timer(pos):start(1)
 	end,
-	sounds = default.node_sound_stone_defaults(),
+	sounds = mesecon.node_sound.stone,
 	mesecons = {receptor = {
 		state = mesecon.state.off,
 		rules = mesecon.rules.buttonlike_get
-	}}
+	}},
+	on_blast = mesecon.on_blastnode,
 })
 
 minetest.register_node("mesecons_button:button_on", {
@@ -62,12 +69,15 @@ minetest.register_node("mesecons_button:button_on", {
 		"jeija_wall_button_sides.png",
 		"jeija_wall_button_sides.png",
 		"jeija_wall_button_on.png"
-		},
+	},
+	use_texture_alpha = use_texture_alpha,
 	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",
@@ -83,16 +93,11 @@ minetest.register_node("mesecons_button:button_on", {
 	groups = {dig_immediate=2, not_in_creative_inventory=1, mesecon_needs_receiver = 1},
 	drop = 'mesecons_button:button_off',
 	description = "Button",
-	sounds = default.node_sound_stone_defaults(),
+	sounds = mesecon.node_sound.stone,
 	mesecons = {receptor = {
 		state = mesecon.state.on,
 		rules = mesecon.rules.buttonlike_get
-	}}
-})
-
-minetest.register_craft({
-	output = "mesecons_button:button_off 2",
-	recipe = {
-		{"group:mesecon_conductor_craftable","default:stone"},
-	}
+	}},
+	on_timer = mesecon.button_turnoff,
+	on_blast = mesecon.on_blastnode,
 })

mesecons_button/mod.conf

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

mesecons_commandblock/depends.txt

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

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

@@ -1,210 +1,214 @@
-minetest.register_chatcommand("say", {
-	params = "<text>",
-	description = "Say <text> as the server",
-	privs = {server=true},
-	func = function(name, param)
-		minetest.chat_send_all(name .. ": " .. param)
-	end
-})
-
-minetest.register_chatcommand("tell", {
-	params = "<name> <text>",
-	description = "Say <text> to <name> privately",
-	func = function(name, param)
-		local found, _, target, message = param:find("^([^%s]+)%s+(.*)$")
-		if found == nil then
-			minetest.chat_send_player(name, "Invalid usage: " .. param)
-			return
-		end
-		if not minetest.get_player_by_name(target) then
-			minetest.chat_send_player(name, "Invalid target: " .. target)
-		end
-		minetest.chat_send_player(target, name .. " whispers: " .. message, false)
-	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",
-	privs = {ban=true},
-	func = function(name, param)
-		local found, _, target, value = param:find("^([^%s]+)%s+(%d+)$")
-		if found == nil then
-			minetest.chat_send_player(name, "Invalid usage: " .. param)
-			return
-		end
-		local player = minetest.get_player_by_name(target)
-		if player then
-			player:set_hp(value)
-		else
-			minetest.chat_send_player(name, "Invalid target: " .. target)
-		end
-	end
-})
-
-local initialize_data = function(meta, player, command, param)
-	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]")
-	local owner = meta:get_string("owner")
-	if owner == "" then
-		owner = "not owned"
-	else
-		owner = "owned by " .. owner
-	end
-	meta:set_string("infotext", "Command Block\n" ..
-		"(" .. owner .. ")\n" ..
-		"Command: /" .. command .. " " .. param)
-end
-
-local construct = function(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("owner", "")
-
-	initialize_data(meta, "@nearest", "time", "7000")
-end
-
-local after_place = function(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")
-	end
-end
-
-local receive_fields = function(pos, formname, fields, sender)
-	if fields.quit 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)
-	end
-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)
-	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())
-			if distance < min_distance then
-				min_distance = distance
-				name = 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()
-			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
-end
-
-local commandblock_action_on = function(pos, node)
-	if node.name ~= "mesecons_commandblock:commandblock_off" then
-		return
-	end
-
-	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, ", ")..")")
-		return
-	end
-	local player = resolve_player(meta:get_string("player"), pos)
-	command.func(player, meta:get_string("param"))
-end
-
-local commandblock_action_off = function(pos, node)
-	if node.name == "mesecons_commandblock:commandblock_on" then
-		minetest.swap_node(pos, {name = "mesecons_commandblock:commandblock_off"})
-	end
-end
-
-minetest.register_node("mesecons_commandblock:commandblock_off", {
-	description = "Command Block",
-	tiles = {"jeija_commandblock_off.png"},
-	inventory_image = minetest.inventorycube("jeija_commandblock_off.png"),
-	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,
-	sounds = default.node_sound_stone_defaults(),
-	mesecons = {effector = {
-		action_on = commandblock_action_on
-	}}
-})
-
-minetest.register_node("mesecons_commandblock:commandblock_on", {
-	tiles = {"jeija_commandblock_on.png"},
-	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,
-	sounds = default.node_sound_stone_defaults(),
-	mesecons = {effector = {
-		action_off = commandblock_action_off
-	}}
-})
+minetest.register_chatcommand("say", {
+	params = "<text>",
+	description = "Say <text> as the server",
+	privs = {server=true},
+	func = function(name, param)
+		minetest.chat_send_all(name .. ": " .. param)
+	end
+})
+
+minetest.register_chatcommand("tell", {
+	params = "<name> <text>",
+	description = "Say <text> to <name> privately",
+	privs = {shout=true},
+	func = function(name, param)
+		local found, _, target, message = param:find("^([^%s]+)%s+(.*)$")
+		if found == nil then
+			minetest.chat_send_player(name, "Invalid usage: " .. param)
+			return
+		end
+		if not minetest.get_player_by_name(target) then
+			minetest.chat_send_player(name, "Invalid target: " .. target)
+		end
+		minetest.chat_send_player(target, name .. " whispers: " .. message, false)
+	end
+})
+
+minetest.register_chatcommand("hp", {
+	params = "<name> <value>",
+	description = "Set health of <name> to <value> hitpoints",
+	privs = {ban=true},
+	func = function(name, param)
+		local found, _, target, value = param:find("^([^%s]+)%s+(%d+)$")
+		if found == nil then
+			minetest.chat_send_player(name, "Invalid usage: " .. param)
+			return
+		end
+		local player = minetest.get_player_by_name(target)
+		if player then
+			player:set_hp(value)
+		else
+			minetest.chat_send_player(name, "Invalid target: " .. target)
+		end
+	end
+})
+
+local function initialize_data(meta)
+	local commands = minetest.formspec_escape(meta:get_string("commands"))
+	meta:set_string("formspec",
+		"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"
+	else
+		owner = "owned by " .. owner
+	end
+	meta:set_string("infotext", "Command Block\n" ..
+		"(" .. owner .. ")\n" ..
+		"Commands: "..commands)
+end
+
+local function construct(pos)
+	local meta = minetest.get_meta(pos)
+
+	meta:set_string("commands", "tell @nearest Commandblock unconfigured")
+
+	meta:set_string("owner", "")
+
+	initialize_data(meta)
+end
+
+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)
+	end
+end
+
+local function receive_fields(pos, _, fields, sender)
+	if not fields.submit then
+		return
+	end
+	local meta = minetest.get_meta(pos)
+	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 function resolve_commands(commands, pos)
+	local players = minetest.get_connected_players()
+
+	-- No players online: remove all commands containing
+	-- @nearest, @farthest and @random
+	if #players == 0 then
+		commands = commands:gsub("[^\r\n]+", function (line)
+			if line:find("@nearest") then return "" end
+			if line:find("@farthest") then return "" end
+			if line:find("@random") then return "" end
+			return line
+		end)
+		return commands
+	end
+
+	local nearest, farthest = nil, nil
+	local min_distance, max_distance = math.huge, -1
+	for index, player in pairs(players) do
+		local distance = vector.distance(pos, player:get_pos())
+		if distance < min_distance then
+			min_distance = distance
+			nearest = player:get_player_name()
+		end
+		if distance > max_distance then
+			max_distance = distance
+			farthest = player:get_player_name()
+		end
+	end
+	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 function commandblock_action_on(pos, node)
+	if node.name ~= "mesecons_commandblock:commandblock_off" then
+		return
+	end
+
+	minetest.swap_node(pos, {name = "mesecons_commandblock:commandblock_on"})
+
+	local meta = minetest.get_meta(pos)
+	local owner = meta:get_string("owner")
+	if owner == "" then
+		return
+	end
+
+	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 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 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() or
+		minetest.check_player_privs(player, "protection_bypass")
+end
+
+minetest.register_node("mesecons_commandblock:commandblock_off", {
+	description = "Command Block",
+	tiles = {"jeija_commandblock_off.png"},
+	inventory_image = minetest.inventorycube("jeija_commandblock_off.png"),
+	is_ground_content = false,
+	groups = {cracky=2, mesecon_effector_off=1},
+	on_construct = construct,
+	after_place_node = after_place,
+	on_receive_fields = receive_fields,
+	can_dig = can_dig,
+	sounds = mesecon.node_sound.stone,
+	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 = can_dig,
+	sounds = mesecon.node_sound.stone,
+	mesecons = {effector = {
+		action_off = commandblock_action_off
+	}},
+	on_blast = mesecon.on_blastnode,
+})

mesecons_commandblock/mod.conf

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

mesecons_compatibility/depends.txt

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

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/depends.txt

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

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

@@ -1,63 +1,32 @@
 -- Function that get the input/output rules of the delayer
-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)
-	end
-	return rules
-end
+local delayer_get_output_rules = mesecon.horiz_rules_getter({{x = 1, y = 0, z = 0}})
 
-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)
-	end
-	return rules
-end
+local delayer_get_input_rules = mesecon.horiz_rules_getter({{x = -1, y = 0, z = 0}})
 
 -- 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
 
+local delaytime = { 0.1, 0.3, 0.5, 1.0 }
+
 for i = 1, 4 do
-local groups = {}
-if i == 1 then 
-	groups = {bendy=2,snappy=1,dig_immediate=2}
-else
-	groups = {bendy=2,snappy=1,dig_immediate=2, not_in_creative_inventory=1}
-end
 
-local delaytime
-if 		i == 1 then delaytime = 0.1
-elseif	i == 2 then delaytime = 0.3
-elseif	i == 3 then delaytime = 0.5
-elseif	i == 4 then delaytime = 1.0 end
-
-boxes = {{ -6/16, -8/16, -6/16, 6/16, -7/16, 6/16 },		-- the main slab
+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,21 +36,13 @@ 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",
+-- Delayer definition defaults
+local def = {
 	drawtype = "nodebox",
-	tiles = {
-		"mesecons_delayer_off_"..tostring(i)..".png",
-		"mesecons_delayer_bottom.png",
-		"mesecons_delayer_ends_off.png",
-		"mesecons_delayer_ends_off.png",
-		"mesecons_delayer_sides_off.png",
-		"mesecons_delayer_sides_off.png"
-		},
-	inventory_image = "mesecons_delayer_off_1.png",
-	wield_image = "mesecons_delayer_off_1.png",
+	use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "opaque" or nil,
 	walkable = true,
 	selection_box = {
 		type = "fixed",
@@ -91,26 +52,46 @@ minetest.register_node("mesecons_delayer:delayer_off_"..tostring(i), {
 		type = "fixed",
 		fixed = boxes
 	},
-	groups = groups,
 	paramtype = "light",
 	paramtype2 = "facedir",
 	sunlight_propagates = true,
-	is_ground_content = true,
-	drop = 'mesecons_delayer:delayer_off_1',
-	on_punch = function (pos, node)
-		if node.name=="mesecons_delayer:delayer_off_1" then
-			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_off_2", param2=node.param2})
-		elseif node.name=="mesecons_delayer:delayer_off_2" then
-			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_off_3", param2=node.param2})
-		elseif node.name=="mesecons_delayer:delayer_off_3" then
-			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_off_4", param2=node.param2})
-		elseif node.name=="mesecons_delayer:delayer_off_4" then
-			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_off_1", param2=node.param2})
+	is_ground_content = false,
+	delayer_time = delaytime[i],
+	sounds = mesecon.node_sound.stone,
+	on_blast = mesecon.on_blastnode,
+	drop = "mesecons_delayer:delayer_off_1",
+}
+
+-- Deactivated delayer definition defaults
+local off_groups = {bendy=2,snappy=1,dig_immediate=2}
+if i > 1 then
+	off_groups.not_in_creative_inventory = 1
+end
+
+local off_state = {
+	description = "Delayer",
+	tiles = {
+		"mesecons_delayer_off_"..tostring(i)..".png",
+		"mesecons_delayer_bottom.png",
+		"mesecons_delayer_ends_off.png",
+		"mesecons_delayer_ends_off.png",
+		"mesecons_delayer_sides_off.png",
+		"mesecons_delayer_sides_off.png"
+	},
+	inventory_image = "mesecons_delayer_off_1.png",
+	wield_image = "mesecons_delayer_off_1.png",
+	groups = off_groups,
+	on_punch = function(pos, node, puncher)
+		if minetest.is_protected(pos, puncher and puncher:get_player_name() or "") then
+			return
 		end
+
+		minetest.swap_node(pos, {
+			name = "mesecons_delayer:delayer_off_"..tostring(i % 4 + 1),
+			param2 = node.param2
+		})
 	end,
-	delayer_time = delaytime,
 	delayer_onstate = "mesecons_delayer:delayer_on_"..tostring(i),
-	sounds = default.node_sound_stone_defaults(),
 	mesecons = {
 		receptor =
 		{
@@ -122,13 +103,16 @@ minetest.register_node("mesecons_delayer:delayer_off_"..tostring(i), {
 			rules = delayer_get_input_rules,
 			action_on = delayer_activate
 		}
-	}
-})
+	},
+}
+for k, v in pairs(def) do
+	off_state[k] = off_state[k] or v
+end
+minetest.register_node("mesecons_delayer:delayer_off_"..tostring(i), off_state)
 
-
-minetest.register_node("mesecons_delayer:delayer_on_"..tostring(i), {
+-- Activated delayer definition defaults
+local on_state = {
 	description = "You hacker you",
-	drawtype = "nodebox",
 	tiles = {
 		"mesecons_delayer_on_"..tostring(i)..".png",
 		"mesecons_delayer_bottom.png",
@@ -136,34 +120,18 @@ minetest.register_node("mesecons_delayer:delayer_on_"..tostring(i), {
 		"mesecons_delayer_ends_on.png",
 		"mesecons_delayer_sides_on.png",
 		"mesecons_delayer_sides_on.png"
-		},
-	walkable = true,
-	selection_box = {
-		type = "fixed",
-		fixed = { -8/16, -8/16, -8/16, 8/16, -6/16, 8/16 },
-	},
-	node_box = {
-		type = "fixed",
-		fixed = boxes
 	},
 	groups = {bendy = 2, snappy = 1, dig_immediate = 2, not_in_creative_inventory = 1},
-	paramtype = "light",
-	paramtype2 = "facedir",
-	sunlight_propagates = true,
-	is_ground_content = true,
-	drop = 'mesecons_delayer:delayer_off_1',
-	on_punch = function (pos, node)
-		if node.name=="mesecons_delayer:delayer_on_1" then
-			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_on_2", param2=node.param2})
-		elseif node.name=="mesecons_delayer:delayer_on_2" then
-			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_on_3", param2=node.param2})
-		elseif node.name=="mesecons_delayer:delayer_on_3" then
-			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_on_4", param2=node.param2})
-		elseif node.name=="mesecons_delayer:delayer_on_4" then
-			minetest.swap_node(pos, {name = "mesecons_delayer:delayer_on_1", param2=node.param2})
+	on_punch = function(pos, node, puncher)
+		if minetest.is_protected(pos, puncher and puncher:get_player_name() or "") then
+			return
 		end
+
+		minetest.swap_node(pos, {
+			name = "mesecons_delayer:delayer_on_"..tostring(i % 4 + 1),
+			param2 = node.param2
+		})
 	end,
-	delayer_time = delaytime,
 	delayer_offstate = "mesecons_delayer:delayer_off_"..tostring(i),
 	mesecons = {
 		receptor =
@@ -176,14 +144,11 @@ minetest.register_node("mesecons_delayer:delayer_on_"..tostring(i), {
 			rules = delayer_get_input_rules,
 			action_off = delayer_deactivate
 		}
-	}
-})
+	},
+}
+for k, v in pairs(def) do
+	on_state[k] = on_state[k] or v
 end
+minetest.register_node("mesecons_delayer:delayer_on_"..tostring(i), on_state)
 
-minetest.register_craft({
-	output = "mesecons_delayer:delayer_off_1",
-	recipe = {
-		{"mesecons_torch:mesecon_torch_on", "group:mesecon_conductor_craftable", "mesecons_torch:mesecon_torch_on"},
-		{"default:cobble","default:cobble", "default:cobble"},
-	}
-})
+end

mesecons_delayer/mod.conf

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

mesecons_detector/depends.txt

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

mesecons_detector/doc/nodedetector/description.html

@@ -0,0 +1,11 @@
+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. For example, you can send
+<code>{distance=4, scanname="default:dirt"}</code>
+to set distance to 4 and scan for dirt. You can omit either parameter.
+There is also a command parameter: <code>{command="get"}</code> will respond
+with the detected nodename and <code>{command="scan"}</code> will respond with
+a boolean using the distance and nodename of the detector.
+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,24 @@
+local side_texture = "mesecons_detector_side.png"
+
+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, _, 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 +26,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 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
-			return true
+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")
+	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, _, 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
@@ -47,64 +66,219 @@ 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"},
+	tiles = {side_texture, side_texture, "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
+	sounds = mesecon.node_sound.stone,
+	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"},
+	tiles = {side_texture, side_texture, "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
+	sounds = mesecon.node_sound.stone,
+	digiline = object_detector_digiline,
+	on_blast = mesecon.on_blastnode,
 })
 
-minetest.register_craft({
-	output = 'mesecons_detector:object_detector_off',
-	recipe = {
-		{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
-		{"default:steel_ingot", "mesecons_luacontroller:luacontroller0000", "default:steel_ingot"},
-		{"default:steel_ingot", "group:mesecon_conductor_craftable", "default:steel_ingot"},
-	}
-})
-
-minetest.register_abm(
-	{nodenames = {"mesecons_detector:object_detector_off"},
-	interval = 1.0,
+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, _, 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
+
+local function node_detector_send_node_name(pos, node, channel, meta)
+	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 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)
+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)
+
+			if channel ~= meta:get_string("digiline_channel") then return end
+
+			if type(msg) == "table" then
+				if msg.distance or msg.scanname then
+					if msg.distance then
+						meta:set_string("distance", msg.distance)
+					end
+					if msg.scanname then
+						meta:set_string("scanname", msg.scanname)
+					end
+					node_detector_make_formspec(pos)
+				end
+				if msg.command == "get" then
+					node_detector_send_node_name(pos, node, channel, meta)
+				elseif msg.command == "scan" then
+					local result = node_detector_scan(pos)
+					digiline:receptor_send(pos, digiline.rules.default, channel, result)
+				end
+			else
+				if msg == GET_COMMAND then
+					node_detector_send_node_name(pos, node, channel, meta)
+				else
+					meta:set_string("scanname", msg)
+					node_detector_make_formspec(pos)
+				end
+			end
+		end,
+	},
+	receptor = {}
+}
+
+minetest.register_node("mesecons_detector:node_detector_off", {
+	tiles = {side_texture, side_texture, side_texture, side_texture, side_texture, "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 = mesecon.node_sound.stone,
+	digiline = node_detector_digiline,
+	on_blast = mesecon.on_blastnode,
+})
+
+minetest.register_node("mesecons_detector:node_detector_on", {
+	tiles = {side_texture, side_texture, side_texture, side_texture, side_texture, "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 = mesecon.node_sound.stone,
+	digiline = node_detector_digiline,
+	on_blast = mesecon.on_blastnode,
+})
+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_detector/mod.conf

@@ -0,0 +1,2 @@
+name = mesecons_detector
+depends = mesecons, mesecons_gamecompat, mesecons_materials

mesecons_extrawires/corner.lua

@@ -1,83 +1,61 @@
-local corner_nodebox = {
-	type = "fixed",
-	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)
-	local rules = 
-	{{x = 1,  y = 0,  z =  0},
-	 {x = 0,  y = 0,  z = -1}}
-
-	for i = 0, node.param2 do
-		rules = mesecon:rotate_rules_left(rules)
-	end
-
-	return rules
-end
+local corner_get_rules = mesecon.horiz_rules_getter({
+	{x = 0, y = 0, z = -1},
+	{x = -1, y = 0, z = 0},
+})
 
 minetest.register_node("mesecons_extrawires:corner_on", {
-	drawtype = "nodebox",
+	drawtype = "mesh",
+	mesh = "mesecons_extrawires_corner.obj",
 	tiles = {
-		"jeija_insulated_wire_curved_tb_on.png",
-		"jeija_insulated_wire_curved_tb_on.png^[transformR270",
-		"jeija_insulated_wire_sides_on.png",
-		"jeija_insulated_wire_ends_on.png",
-		"jeija_insulated_wire_sides_on.png",
-		"jeija_insulated_wire_ends_on.png"
+		{ name = "jeija_insulated_wire_sides_on.png", backface_culling = true },
+		{ name = "jeija_insulated_wire_ends_on.png", backface_culling = true },
 	},
 	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",
-	mesecons = {conductor = 
+	sounds = mesecon.node_sound.default,
+	mesecons = {conductor =
 	{
 		state = mesecon.state.on,
 		rules = corner_get_rules,
 		offstate = "mesecons_extrawires:corner_off"
-	}}
+	}},
+	on_blast = mesecon.on_blastnode,
+	on_rotate = mesecon.on_rotate_horiz,
 })
 
 minetest.register_node("mesecons_extrawires:corner_off", {
-	drawtype = "nodebox",
-	description = "Mesecon Corner",
+	drawtype = "mesh",
+	description = "Insulated Mesecon Corner",
+	mesh = "mesecons_extrawires_corner.obj",
 	tiles = {
-		"jeija_insulated_wire_curved_tb_off.png",
-		"jeija_insulated_wire_curved_tb_off.png^[transformR270",
-		"jeija_insulated_wire_sides_off.png",
-		"jeija_insulated_wire_ends_off.png",
-		"jeija_insulated_wire_sides_off.png",
-		"jeija_insulated_wire_ends_off.png"
+		{ name = "jeija_insulated_wire_sides_off.png", backface_culling = true },
+		{ name = "jeija_insulated_wire_ends_off.png", backface_culling = true },
 	},
 	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},
-	mesecons = {conductor = 
+	sounds = mesecon.node_sound.default,
+	mesecons = {conductor =
 	{
 		state = mesecon.state.off,
 		rules = corner_get_rules,
 		onstate = "mesecons_extrawires:corner_on"
-	}}
-})
-
-minetest.register_craft({
-	output = "mesecons_extrawires:corner_off 3",
-	recipe = {
-		{"", "", ""},
-		{"mesecons_insulated:insulated_off", "mesecons_insulated:insulated_off", ""},
-		{"", "mesecons_insulated:insulated_off", ""},
-	}
+	}},
+	on_blast = mesecon.on_blastnode,
+	on_rotate = mesecon.on_rotate_horiz,
 })

mesecons_extrawires/crossover.lua

@@ -1,15 +1,13 @@
-function crossover_get_rules(node)
-	return {
-		{--first wire
-			{x=-1,y=0,z=0},
-			{x=1,y=0,z=0},
-		},
-		{--second wire
-			{x=0,y=0,z=-1},
-			{x=0,y=0,z=1},
-		},
-	}
-end
+local crossover_rules = {
+	{--first wire
+		{x=-1,y=0,z=0},
+		{x=1,y=0,z=0},
+	},
+	{--second wire
+		{x=0,y=0,z=-1},
+		{x=0,y=0,z=1},
+	},
+}
 
 local crossover_states = {
 	"mesecons_extrawires:crossover_off",
@@ -19,158 +17,108 @@ 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 = mesecon.node_sound.default,
 	mesecons = {
 		conductor = {
 			states = crossover_states,
-			rules = crossover_get_rules(),
+			rules = crossover_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 = mesecon.node_sound.default,
 	mesecons = {
 		conductor = {
 			states = crossover_states,
-			rules = crossover_get_rules(),
+			rules = crossover_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 = mesecon.node_sound.default,
 	mesecons = {
 		conductor = {
 			states = crossover_states,
-			rules = crossover_get_rules(),
+			rules = crossover_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 = mesecon.node_sound.default,
 	mesecons = {
 		conductor = {
 			states = crossover_states,
-			rules = crossover_get_rules(),
+			rules = crossover_rules,
 		}
 	},
-})
-
-minetest.register_craft({
-	type = "shapeless",
-	output = "mesecons_extrawires:crossover_off",
-	recipe = {
-		"mesecons_insulated:insulated_off",
-		"mesecons_insulated:insulated_off",
-	},
-})
-
-minetest.register_craft({
-	type = "shapeless",
-	output = "mesecons_insulated:insulated_off 2",
-	recipe = {
-		"mesecons_extrawires:crossover_off",
-	},
-})
+	on_blast = mesecon.on_blastnode,
+})

mesecons_extrawires/depends.txt

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

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.