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"},
+}

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!
 
-[DOWNLOAD IT NOW](https://github.com/Jeija/minetest-mod-mesecons/archive/master.zip)
+[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.
@@ -43,9 +43,11 @@ Or maybe a [comprehensive reference](http://mesecons.net/items.html) is your sty
 
 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?
 ---------------------
@@ -72,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"
+    ]
+}

mesecons/actionqueue.lua

@@ -1,96 +1,140 @@
-mesecon.queue.actions={} -- contains all ActionQueue actions
+--[[
+Mesecons uses something it calls an ActionQueue.
 
-function mesecon.queue:add_function(name, func)
-	mesecon.queue.funcs[name] = func
+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 mesecon.queue:add_action(pos, func, params, time, overwritecheck, priority)
+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}
+	local action = {
+		pos = mesecon.tablecopy(pos),
+		func = func,
+		params = mesecon.tablecopy(params or {}),
+		time = time,
+		owcheck = (overwritecheck and mesecon.tablecopy(overwritecheck)) or nil,
+		priority = priority
+	}
 
-	local toremove = nil
-	-- Otherwise, add the action to the queue
-	if overwritecheck then -- check if old action has to be overwritten / removed:
-		for i, ac in ipairs(mesecon.queue.actions) do
-			if(vector.equals(pos, ac.pos)
-			and mesecon.cmpAny(overwritecheck, ac.owcheck)) then
-				toremove = i
+	 -- 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
 
-	if (toremove ~= nil) then
-		table.remove(mesecon.queue.actions, toremove)
-	end
-
-	table.insert(mesecon.queue.actions, action)
+	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
+-- 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 5 seconds
-local get_highest_priority = function (actions)
-	local highestp = -1
-	local highesti
-	for i, ac in ipairs(actions) do
-		if ac.priority > highestp then
-			highestp = ac.priority
-			highesti = i
-		end
-	end
+-- start to be execute by 4 seconds
 
-	return highesti
-end
+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 = {}
 
-local m_time = 0
-local resumetime = mesecon.setting("resumetime", 4)
-minetest.register_globalstep(function (dtime)
-	m_time = m_time + dtime
-	-- don't even try if server has not been running for XY seconds; resumetime = time to wait
-	-- after starting the server before processing the ActionQueue, don't set this too low
-	if (m_time < resumetime) then return end
-	local actions = mesecon.tablecopy(mesecon.queue.actions)
-	local actions_now={}
-
-	mesecon.queue.actions = {}
-
-	-- sort actions into two categories:
-	-- those toexecute now (actions_now) and those to execute later (mesecon.queue.actions)
-	for i, ac in ipairs(actions) do
+	for _, ac in ipairs(actions) do
 		if ac.time > 0 then
-			ac.time = ac.time - dtime -- executed later
-			table.insert(mesecon.queue.actions, ac)
+			-- 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
 
-	while(#actions_now > 0) do -- execute highest priorities first, until all are executed
-		local hp = get_highest_priority(actions_now)
-		mesecon.queue:execute(actions_now[hp])
-		table.remove(actions_now, hp)
+	-- 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
-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)
 
-function mesecon.queue:execute(action)
+	-- 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 mesecon.queue.funcs[action.func] then
-		mesecon.queue.funcs[action.func](action.pos, unpack(action.params))
+	if self.funcs[action.func] then
+		self.funcs[action.func](action.pos, unpack(action.params))
 	end
 end
 
@@ -98,8 +142,8 @@ end
 -- Store and read the ActionQueue to / from a file
 -- so that upcoming actions are remembered when the game
 -- is restarted
-mesecon.queue.actions = mesecon.file2table("mesecon_actionqueue")
+queue.actions = mesecon.file2table("mesecon_actionqueue")
 
 minetest.register_on_shutdown(function()
-	mesecon.table2file("mesecon_actionqueue", mesecon.queue.actions)
+	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/internal.lua

@@ -11,7 +11,7 @@
 
 -- RECEPTORS
 -- mesecon.is_receptor(nodename)	--> Returns true if nodename is a receptor
--- mesecon.is_receptor_on(nodename	--> Returns true if nodename is an receptor with state = mesecon.state.on
+-- mesecon.is_receptor_on(nodename)	--> Returns true if nodename is an receptor with state = mesecon.state.on
 -- mesecon.is_receptor_off(nodename)	--> Returns true if nodename is an receptor with state = mesecon.state.off
 -- mesecon.receptor_get_rules(node)	--> Returns the rules of the receptor (mesecon.rules.default if none specified)
 
@@ -46,6 +46,9 @@
 -- mesecon.rotate_rules_down(rules)
 -- These functions return rules that have been rotated in the specific direction
 
+-- See fifo_queue.lua for documentation.
+mesecon.fifo_queue = dofile(minetest.get_modpath("mesecons").."/fifo_queue.lua")
+
 -- General
 function mesecon.get_effector(nodename)
 	if  minetest.registered_nodes[nodename]
@@ -92,8 +95,8 @@ function mesecon.get_any_inputrules(node)
 end
 
 function mesecon.get_any_rules(node)
-	return mesecon.mergetable(mesecon.get_any_inputrules(node) or {},
-		mesecon.get_any_outputrules(node) or {})
+	return mesecon.merge_rule_sets(mesecon.get_any_inputrules(node),
+		mesecon.get_any_outputrules(node))
 end
 
 -- Receptors
@@ -316,7 +319,7 @@ function mesecon.get_conductor_on(node_off, rulename)
 			return conductor.states[tonumber(binstate,2)+1]
 		end
 	end
-	return offstate
+	return nil
 end
 
 function mesecon.get_conductor_off(node_on, rulename)
@@ -332,7 +335,7 @@ function mesecon.get_conductor_off(node_on, rulename)
 			return conductor.states[tonumber(binstate,2)+1]
 		end
 	end
-	return onstate
+	return nil
 end
 
 function mesecon.conductor_get_rules(node)
@@ -366,37 +369,98 @@ function mesecon.is_power_off(pos, rulename)
 	return false
 end
 
+-- The set of conductor states which require light updates when they change.
+local light_update_conductors
+
+-- Calculate the contents of the above set if they have not been calculated.
+local function find_light_update_conductors()
+	-- The expensive calculation is only done the first time.
+	if light_update_conductors then return end
+
+	light_update_conductors = {}
+
+	-- Find conductors whose lighting characteristics change depending on their state.
+	local checked = {}
+	for name, def in pairs(minetest.registered_nodes) do
+		local conductor = mesecon.get_conductor(name)
+		if conductor and not checked[name] then
+			-- Find the other states of the conductor besides the current one.
+			local other_states
+			if conductor.onstate then
+				other_states = {conductor.onstate}
+			elseif conductor.offstate then
+				other_states = {conductor.offstate}
+			else
+				other_states = conductor.states
+			end
+
+			-- Check the conductor. Other states are marked as checked.
+			for _, other_state in ipairs(other_states) do
+				local other_def = minetest.registered_nodes[other_state]
+				if (def.paramtype == "light") ~= (other_def.paramtype == "light")
+				or def.sunlight_propagates ~= other_def.sunlight_propagates
+				or def.light_source ~= other_def.light_source then
+					-- The light characteristics change depending on the state.
+					-- The states are added to the set.
+					light_update_conductors[name] = true
+					for _, other_state in ipairs(other_states) do
+						light_update_conductors[other_state] = true
+						checked[other_state] = true
+					end
+					break
+				end
+				checked[other_state] = true
+			end
+		end
+	end
+end
+
 -- Turn off an equipotential section starting at `pos`, which outputs in the direction of `link`.
 -- Breadth-first search. Map is abstracted away in a voxelmanip.
 -- Follow all all conductor paths replacing conductors that were already
 -- looked at, activating / changing all effectors along the way.
 function mesecon.turnon(pos, link)
-	local frontiers = {{pos = pos, link = link}}
+	find_light_update_conductors()
+
+	local frontiers = mesecon.fifo_queue.new()
+	frontiers:add({pos = pos, link = link})
+	local pos_can_be_skipped = {}
 
 	local depth = 1
-	while frontiers[1] do
-		local f = table.remove(frontiers, 1)
+	for f in frontiers:iter() do
 		local node = mesecon.get_node_force(f.pos)
 
 		if not node then
 			-- Area does not exist; do nothing
-		elseif mesecon.is_conductor_off(node, f.link) then
+			pos_can_be_skipped[minetest.hash_node_position(f.pos)] = true
+		elseif mesecon.is_conductor(node.name) then
 			local rules = mesecon.conductor_get_rules(node)
 
-			-- Call turnon on neighbors
-			for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
-				local np = vector.add(f.pos, r)
-				for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
-					table.insert(frontiers, {pos = np, link = l})
+			if mesecon.is_conductor_off(node, f.link) then
+				-- Call turnon on neighbors
+				for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
+					local np = vector.add(f.pos, r)
+					if not pos_can_be_skipped[minetest.hash_node_position(np)] then
+						for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
+							frontiers:add({pos = np, link = l})
+						end
+					end
 				end
+
+				mesecon.swap_node_force(f.pos, mesecon.get_conductor_on(node, f.link), light_update_conductors[node.name] ~= nil)
 			end
 
-			mesecon.swap_node_force(f.pos, mesecon.get_conductor_on(node, f.link))
+			-- Only conductors with flat rules can be reliably skipped later
+			if not rules[1] or rules[1].x then
+				pos_can_be_skipped[minetest.hash_node_position(f.pos)] = true
+			end
 		elseif mesecon.is_effector(node.name) then
 			mesecon.changesignal(f.pos, node, f.link, mesecon.state.on, depth)
 			if mesecon.is_effector_off(node.name) then
 				mesecon.activate(f.pos, node, f.link, depth)
 			end
+		else
+			pos_can_be_skipped[minetest.hash_node_position(f.pos)] = true
 		end
 		depth = depth + 1
 	end
@@ -419,37 +483,51 @@ end
 --	depth = indicates order in which signals wire fired, higher is later
 -- }
 function mesecon.turnoff(pos, link)
-	local frontiers = {{pos = pos, link = link}}
+	find_light_update_conductors()
+
+	local frontiers = mesecon.fifo_queue.new()
+	frontiers:add({pos = pos, link = link})
 	local signals = {}
+	local pos_can_be_skipped = {}
 
 	local depth = 1
-	while frontiers[1] do
-		local f = table.remove(frontiers, 1)
+	for f in frontiers:iter() do
 		local node = mesecon.get_node_force(f.pos)
 
 		if not node then
 			-- Area does not exist; do nothing
-		elseif mesecon.is_conductor_on(node, f.link) then
+			pos_can_be_skipped[minetest.hash_node_position(f.pos)] = true
+		elseif mesecon.is_conductor(node.name) then
 			local rules = mesecon.conductor_get_rules(node)
-			for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
-				local np = vector.add(f.pos, r)
 
-				-- Check if an onstate receptor is connected. If that is the case,
-				-- abort this turnoff process by returning false. `receptor_off` will
-				-- discard all the changes that we made in the voxelmanip:
-				for _, l in ipairs(mesecon.rules_link_rule_all_inverted(f.pos, r)) do
-					if mesecon.is_receptor_on(mesecon.get_node_force(np).name) then
-						return false
+			if mesecon.is_conductor_on(node, f.link) then
+				for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
+					local np = vector.add(f.pos, r)
+
+					if not pos_can_be_skipped[minetest.hash_node_position(np)] then
+						-- Check if an onstate receptor is connected. If that is the case,
+						-- abort this turnoff process by returning false. `receptor_off` will
+						-- discard all the changes that we made in the voxelmanip:
+						if mesecon.rules_link_rule_all_inverted(f.pos, r)[1] then
+							if mesecon.is_receptor_on(mesecon.get_node_force(np).name) then
+								return false
+							end
+						end
+
+						-- Call turnoff on neighbors
+						for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
+							frontiers:add({pos = np, link = l})
+						end
 					end
 				end
 
-				-- Call turnoff on neighbors
-				for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
-					table.insert(frontiers, {pos = np, link = l})
-				end
+				mesecon.swap_node_force(f.pos, mesecon.get_conductor_off(node, f.link), light_update_conductors[node.name] ~= nil)
 			end
 
-			mesecon.swap_node_force(f.pos, mesecon.get_conductor_off(node, f.link))
+			-- Only conductors with flat rules can be reliably skipped later
+			if not rules[1] or rules[1].x then
+				pos_can_be_skipped[minetest.hash_node_position(f.pos)] = true
+			end
 		elseif mesecon.is_effector(node.name) then
 			table.insert(signals, {
 				pos = f.pos,
@@ -457,6 +535,8 @@ function mesecon.turnoff(pos, link)
 				link = f.link,
 				depth = depth
 			})
+		else
+			pos_can_be_skipped[minetest.hash_node_position(f.pos)] = true
 		end
 		depth = depth + 1
 	end
@@ -548,52 +628,3 @@ function mesecon.is_powered(pos, rule)
 	if (#sourcepos == 0) then return false
 	else return sourcepos end
 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

mesecons/legacy.lua

@@ -11,4 +11,4 @@ local old_forceloaded_blocks = mesecon.file2table("mesecon_forceloaded")
 for hash, _ in pairs(old_forceloaded_blocks) do
 	minetest.forceload_free_block(unhash_blockpos(hash))
 end
-os.remove(minetest.get_worldpath()..DIR_DELIM.."mesecon_forceloaded")
+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 = default.LIGHT_MAX-11,
+	light_source = minetest.LIGHT_MAX-11,
 	mesecons = {conductor={
 		state = mesecon.state.on,
 		offstate = "mesecons:mesecon_off"

mesecons/presets.lua

@@ -1,61 +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.pplate = mesecon.mergetable(mesecon.rules.default, {{x=0, y=-2, z=0}})
+mesecon.rules.floor = mesecon.merge_rule_sets(mesecon.rules.default, {{x = 0, y = -1, 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.pplate = mesecon.merge_rule_sets(mesecon.rules.floor, {{x = 0, y = -2, 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.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.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}}
+mesecon.rules.flat = {
+	{x =  1, y = 0, z =  0},
+	{x = -1, y = 0, z =  0},
+	{x =  0, y = 0, z =  1},
+	{x =  0, y = 0, z = -1},
+}
+
+mesecon.rules.alldirs = {
+	{x =  1, y =  0,  z =  0},
+	{x = -1, y =  0,  z =  0},
+	{x =  0, y =  1,  z =  0},
+	{x =  0, y = -1,  z =  0},
+	{x =  0, y =  0,  z =  1},
+	{x =  0, y =  0,  z = -1},
+}
+
+local rules_wallmounted = {
+	xp = mesecon.rotate_rules_down(mesecon.rules.floor),
+	xn = mesecon.rotate_rules_up(mesecon.rules.floor),
+	yp = mesecon.rotate_rules_up(mesecon.rotate_rules_up(mesecon.rules.floor)),
+	yn = mesecon.rules.floor,
+	zp = mesecon.rotate_rules_left(mesecon.rotate_rules_up(mesecon.rules.floor)),
+	zn = mesecon.rotate_rules_right(mesecon.rotate_rules_up(mesecon.rules.floor)),
+}
+
+local rules_buttonlike = {
+	xp = mesecon.rules.buttonlike,
+	xn = mesecon.rotate_rules_right(mesecon.rotate_rules_right(mesecon.rules.buttonlike)),
+	yp = mesecon.rotate_rules_down(mesecon.rules.buttonlike),
+	yn = mesecon.rotate_rules_up(mesecon.rules.buttonlike),
+	zp = mesecon.rotate_rules_right(mesecon.rules.buttonlike),
+	zn = mesecon.rotate_rules_left(mesecon.rules.buttonlike),
+}
+
+local function rules_from_dir(ruleset, dir)
+	if dir.x ==  1 then return ruleset.xp end
+	if dir.y ==  1 then return ruleset.yp end
+	if dir.z ==  1 then return ruleset.zp end
+	if dir.x == -1 then return ruleset.xn end
+	if dir.y == -1 then return ruleset.yn end
+	if dir.z == -1 then return ruleset.zn end
+end
+
+mesecon.rules.wallmounted_get = function(node)
+	local dir = minetest.wallmounted_to_dir(node.param2)
+	return rules_from_dir(rules_wallmounted, dir)
+end
 
 mesecon.rules.buttonlike_get = function(node)
-	local rules = mesecon.rules.buttonlike
 	local dir = minetest.facedir_to_dir(node.param2)
-	if dir.x == 1 then
-		-- No action needed
-	elseif dir.z == -1 then
-		rules=mesecon.rotate_rules_left(rules)
-	elseif dir.x == -1 then
-		rules=mesecon.rotate_rules_right(mesecon.rotate_rules_right(rules))
-	elseif dir.z == 1 then
-		rules=mesecon.rotate_rules_right(rules)
-	elseif dir.y == -1 then
-		rules=mesecon.rotate_rules_up(rules)
-	elseif dir.y == 1 then
-		rules=mesecon.rotate_rules_down(rules)
-	end
-	return rules
+	return rules_from_dir(rules_buttonlike, dir)
 end
 
 mesecon.state.on = "on"

mesecons/services.lua

@@ -2,6 +2,7 @@
 
 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
@@ -11,17 +12,20 @@ mesecon.on_placenode = function(pos, node)
 	-- 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
-			-- also call receptor_on if itself is powered already, so that neighboring
-			-- conductors will be activated (when pushing an on-conductor with a piston)
+			mesecon.vm_begin()
 			for _, s in ipairs(sources) do
-				local rule = vector.subtract(pos, s)
+				local rule = vector.subtract(s, pos)
 				mesecon.turnon(pos, rule)
 			end
-			--mesecon.receptor_on (pos, mesecon.conductor_get_rules(node))
-		elseif mesecon.is_conductor_on(node) then
-			minetest.swap_node(pos, {name = mesecon.get_conductor_off(node)})
+			mesecon.vm_commit()
 		end
 	end
 
@@ -62,34 +66,74 @@ mesecon.on_dignode = function(pos, node)
 	mesecon.execute_autoconnect_hooks_queue(pos, node)
 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
-mesecon.do_overheat = function(pos)
-	local meta = minetest.get_meta(pos)
-	local heat = meta:get_int("heat") or 0
-
-	heat = heat + 1
-	meta:set_int("heat", heat)
-
-	if heat < mesecon.setting("overheat_max", 20) then
-		mesecon.queue:add_action(pos, "cooldown", {}, 1, nil, 0)
-	else
+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
 
-mesecon.queue:add_function("cooldown", function (pos)
-	local meta = minetest.get_meta(pos)
-	local heat = meta:get_int("heat")
+function mesecon.get_heat(pos)
+	local id = minetest.hash_node_position(pos)
+	return object_heat[id] or 0
+end
 
-	if (heat > 0) then
-		meta:set_int("heat", heat - 1)
+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
-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,15 +1,15 @@
 -- SETTINGS
 function mesecon.setting(setting, default)
 	if type(default) == "boolean" then
-		local read = minetest.setting_getbool("mesecon."..setting)
+		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.setting_get("mesecon."..setting) or default
+		return minetest.settings:get("mesecon."..setting) or default
 	elseif type(default) == "number" then
-		return tonumber(minetest.setting_get("mesecon."..setting) or default)
+		return tonumber(minetest.settings:get("mesecon."..setting) or default)
 	end
 end

mesecons/util.lua

@@ -6,6 +6,95 @@ function mesecon.move_node(pos, newpos)
 	minetest.get_meta(pos):from_table(meta)
 end
 
+-- 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
+
+-- 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)
 --[[
 	{
@@ -114,7 +203,9 @@ end
 
 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
 
@@ -136,34 +227,36 @@ function mesecon.invertRule(r)
 	return vector.multiply(r, -1)
 end
 
-function mesecon.tablecopy(table) -- deep table copy
-	if type(table) ~= "table" then return table end -- no need to copy
-	local newtable = {}
-
-	for idx, item in pairs(table) do
-		if type(item) == "table" then
-			newtable[idx] = mesecon.tablecopy(item)
-		else
-			newtable[idx] = item
-		end
+function mesecon.tablecopy(obj) -- deep copy
+	if type(obj) == "table" then
+		return table.copy(obj)
 	end
-
-	return newtable
+	return obj
 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" and type(t2) ~= "table" then return t1 == t2 end
+	if type(t1) ~= "table" then return t1 == t2 end
 
+	-- Check that for each key of `t1` both tables have the same value
 	for i, e in pairs(t1) do
 		if not mesecon.cmpAny(e, t2[i]) then return false end
 	end
 
+	-- Check that all keys of `t2` are also keys of `t1` so were checked in the previous loop
+	for i, _ in pairs(t2) do
+		if t1[i] == nil then return false end
+	end
+
 	return true
 end
 
--- does not overwrite values; number keys (ipairs) are appended, not overwritten
+-- 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
@@ -176,14 +269,41 @@ function mesecon.mergetable(source, dest)
 	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.mergetable(spec_common, spec_on);
-	spec_off = mesecon.mergetable(spec_common, spec_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)
@@ -205,7 +325,7 @@ end
 -- File writing / reading utilities
 local wpath = minetest.get_worldpath()
 function mesecon.file2table(filename)
-	local f = io.open(wpath..DIR_DELIM..filename, "r")
+	local f = io.open(wpath.."/"..filename, "r")
 	if f == nil then return {} end
 	local t = f:read("*all")
 	f:close()
@@ -214,7 +334,7 @@ function mesecon.file2table(filename)
 end
 
 function mesecon.table2file(filename, table)
-	local f = io.open(wpath..DIR_DELIM..filename, "w")
+	local f = io.open(wpath.."/"..filename, "w")
 	f:write(minetest.serialize(table))
 	f:close()
 end
@@ -236,15 +356,17 @@ end
 --
 -- Contents of the table are:
 -- “vm” → the VoxelManipulator
--- “va” → the VoxelArea
--- “data” → the data array
--- “param1” → the param1 array
--- “param2” → the param2 array
 -- “dirty” → true if data has been modified
 --
 -- Nil if no VM-based transaction is in progress.
 local vm_cache = nil
 
+-- 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
@@ -253,6 +375,8 @@ local vm_cache = nil
 -- 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
@@ -261,18 +385,19 @@ function mesecon.vm_commit()
 	for hash, tbl in pairs(vm_cache) do
 		if tbl.dirty then
 			local vm = tbl.vm
-			vm:set_data(tbl.data)
-			vm:write_to_map()
+			vm: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.
@@ -280,10 +405,7 @@ local function vm_get_or_create_entry(pos)
 	local hash = hash_blockpos(pos)
 	local tbl = vm_cache[hash]
 	if not tbl then
-		local vm = minetest.get_voxel_manip(pos, pos)
-		local min_pos, max_pos = vm:get_emerged_area()
-		local va = VoxelArea:new{MinEdge = min_pos, MaxEdge = max_pos}
-		tbl = {vm = vm, va = va, data = vm:get_data(), param1 = vm:get_light_data(), param2 = vm:get_param2_data(), dirty = false}
+		tbl = {vm = minetest.get_voxel_manip(pos, pos), dirty = false}
 		vm_cache[hash] = tbl
 	end
 	return tbl
@@ -292,25 +414,34 @@ end
 -- Gets the node at a given position during a VoxelManipulator-based
 -- transaction.
 function mesecon.vm_get_node(pos)
-	local tbl = vm_get_or_create_entry(pos)
-	local index = tbl.va:indexp(pos)
-	local node_value = tbl.data[index]
-	if node_value == core.CONTENT_IGNORE then
-		return nil
-	else
-		local node_param1 = tbl.param1[index]
-		local node_param2 = tbl.param2[index]
-		return {name = minetest.get_name_from_content_id(node_value), param1 = node_param1, param2 = node_param2}
+	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.
-function mesecon.vm_swap_node(pos, name)
+--
+-- 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 index = tbl.va:indexp(pos)
-	tbl.data[index] = minetest.get_content_id(name)
+	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
 
@@ -346,9 +477,11 @@ end
 --
 -- This function can only be used to change the node’s name, not its parameters
 -- or metadata.
-function mesecon.swap_node_force(pos, name)
+--
+-- 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)
+		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.

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

@@ -1 +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

@@ -24,14 +24,21 @@ mesecon.register_node("mesecons_blinkyplant:blinky_plant", {
 	drawtype = "plantlike",
 	inventory_image = "jeija_blinky_plant_off.png",
 	paramtype = "light",
+	is_ground_content = false,
 	walkable = false,
-	sounds = default.node_sound_leaves_defaults(),
+	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 = toggle_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,
 	on_construct = toggle_timer
 },{
 	tiles = {"jeija_blinky_plant_off.png"},
@@ -41,11 +48,4 @@ mesecon.register_node("mesecons_blinkyplant:blinky_plant", {
 	tiles = {"jeija_blinky_plant_on.png"},
 	groups = {dig_immediate=3, not_in_creative_inventory=1},
 	mesecons = {receptor = { state = mesecon.state.on }}
-})
-
-minetest.register_craft({
-	output = "mesecons_blinkyplant:blinky_plant_off 1",
-	recipe = {	{"","group:mesecon_conductor_craftable",""},
-			{"","group:mesecon_conductor_craftable",""},
-			{"group:sapling","group:sapling","group:sapling"}}
-})
+})

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/init.lua

@@ -4,26 +4,31 @@
 
 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,
@@ -44,14 +49,15 @@ minetest.register_node("mesecons_button:button_off", {
 	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)
+		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", {
@@ -63,13 +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,
 	on_rotate = false,
-	light_source = default.LIGHT_MAX-7,
+	light_source = minetest.LIGHT_MAX-7,
 	sunlight_propagates = true,
 	selection_box = {
 		type = "fixed",
@@ -85,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

@@ -1 +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

@@ -10,6 +10,7 @@ minetest.register_chatcommand("say", {
 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
@@ -78,7 +79,7 @@ local function after_place(pos, placer)
 	end
 end
 
-local function receive_fields(pos, formname, fields, sender)
+local function receive_fields(pos, _, fields, sender)
 	if not fields.submit then
 		return
 	end
@@ -110,7 +111,7 @@ local function resolve_commands(commands, pos)
 	local nearest, farthest = nil, nil
 	local min_distance, max_distance = math.huge, -1
 	for index, player in pairs(players) do
-		local distance = vector.distance(pos, player:getpos())
+		local distance = vector.distance(pos, player:get_pos())
 		if distance < min_distance then
 			min_distance = distance
 			nearest = player:get_player_name()
@@ -174,26 +175,30 @@ 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()
+	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 = default.node_sound_stone_defaults(),
+	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",
@@ -201,8 +206,9 @@ minetest.register_node("mesecons_commandblock:commandblock_on", {
 	after_place_node = after_place,
 	on_receive_fields = receive_fields,
 	can_dig = can_dig,
-	sounds = default.node_sound_stone_defaults(),
+	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_delayer/depends.txt

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

mesecons_delayer/doc/delayer/description.html

@@ -1 +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.
+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,19 +1,7 @@
 -- 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
 
@@ -33,19 +21,9 @@ end
 
 -- Register the 2 (states) x 4 (delay times) delayers
 
-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 = { 0.1, 0.3, 0.5, 1.0 }
 
-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
+for i = 1, 4 do
 
 local boxes = {
 	 { -6/16, -8/16, -6/16, 6/16, -7/16, 6/16 },		-- the main slab
@@ -61,19 +39,10 @@ local boxes = {
 	 { 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",
@@ -83,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 =
 		{
@@ -114,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",
@@ -128,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 =
@@ -168,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

@@ -1,6 +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. You can either send "GET" and it will
-respond with the detected nodename or you can send any other string and it will
-set this string as the node to scan for.
+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

@@ -1,3 +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,3 +1,5 @@
+local side_texture = "mesecons_detector_side.png"
+
 local GET_COMMAND = "GET"
 
 -- Object detector
@@ -5,15 +7,18 @@ local GET_COMMAND = "GET"
 -- The radius can be specified in mesecons/settings.lua
 
 local function object_detector_make_formspec(pos)
-	minetest.get_meta(pos):set_string("formspec", "size[9,2.5]" ..
+	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}]"..
 		"button_exit[7,0.75;2,3;;Save]")
 end
 
-local function object_detector_on_receive_fields(pos, _, fields)
+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)
@@ -28,14 +33,17 @@ local function object_detector_scan(pos)
 	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
-			-- return true if scanning for any player or if specific playername was detected
-			if scanname == "" or foundname == scanname then
+			if every_player or scan_for[foundname] then
 				return true
 			end
 		end
@@ -47,7 +55,7 @@ end
 -- set player name when receiving a digiline signal on a specific channel
 local object_detector_digiline = {
 	effector = {
-		action = function(pos, node, channel, msg)
+		action = function(pos, _, channel, msg)
 			local meta = minetest.get_meta(pos)
 			if channel == meta:get_string("digiline_channel") then
 				meta:set_string("scanname", msg)
@@ -58,8 +66,9 @@ local 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",
@@ -69,13 +78,15 @@ minetest.register_node("mesecons_detector:object_detector_off", {
 	}},
 	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',
@@ -85,17 +96,9 @@ minetest.register_node("mesecons_detector:object_detector_on", {
 	}},
 	on_construct = object_detector_make_formspec,
 	on_receive_fields = object_detector_on_receive_fields,
-	sounds = default.node_sound_stone_defaults(),
-	digiline = object_detector_digiline
-})
-
-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"},
-	}
+	sounds = mesecon.node_sound.stone,
+	digiline = object_detector_digiline,
+	on_blast = mesecon.on_blastnode,
 })
 
 minetest.register_abm({
@@ -128,17 +131,23 @@ minetest.register_abm({
 -- Detects the node in front of it
 
 local function node_detector_make_formspec(pos)
-	minetest.get_meta(pos):set_string("formspec", "size[9,2.5]" ..
+	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;4,2;digiline_channel;Digiline Channel (optional):;${digiline_channel}]"..
+		"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)
+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
@@ -148,58 +157,76 @@ 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, minetest.facedir_to_dir(node.param2))
+		vector.subtract(pos, vector.multiply(minetest.facedir_to_dir(node.param2), distance + 1))
 	).name
-	local scanname = minetest.get_meta(pos):get_string("scanname")
+	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 msg == GET_COMMAND then
-				local nodename = minetest.get_node(
-					vector.subtract(pos, minetest.facedir_to_dir(node.param2))
-				).name
-
-				digiline:receptor_send(pos, digiline.rules.default, channel, nodename)
+			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
-				meta:set_string("scanname", msg)
-				node_detector_make_formspec(pos)
+				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 = {}
 }
 
-local function after_place_node_detector(pos, placer)
-	local placer_pos = placer:getpos()
-	if not placer_pos then
-		return
-	end
-
-	--correct for the player's height
-	if placer:is_player() then
-		placer_pos.y = placer_pos.y + 1.625
-	end
-
-	--correct for 6d facedir
-	local node = minetest.get_node(pos)
-	node.param2 = minetest.dir_to_facedir(vector.subtract(pos, placer_pos), true)
-	minetest.set_node(pos, node)
-end
-
 minetest.register_node("mesecons_detector:node_detector_off", {
-	tiles = {"default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "jeija_node_detector_off.png"},
+	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",
@@ -208,15 +235,16 @@ minetest.register_node("mesecons_detector:node_detector_off", {
 	}},
 	on_construct = node_detector_make_formspec,
 	on_receive_fields = node_detector_on_receive_fields,
-	after_place_node = after_place_node_detector,
-	sounds = default.node_sound_stone_defaults(),
-	digiline = node_detector_digiline
+	sounds = mesecon.node_sound.stone,
+	digiline = node_detector_digiline,
+	on_blast = mesecon.on_blastnode,
 })
 
 minetest.register_node("mesecons_detector:node_detector_on", {
-	tiles = {"default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "jeija_node_detector_on.png"},
+	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',
@@ -225,20 +253,10 @@ minetest.register_node("mesecons_detector:node_detector_on", {
 	}},
 	on_construct = node_detector_make_formspec,
 	on_receive_fields = node_detector_on_receive_fields,
-	after_place_node = after_place_node_detector,
-	sounds = default.node_sound_stone_defaults(),
-	digiline = node_detector_digiline
+	sounds = mesecon.node_sound.stone,
+	digiline = node_detector_digiline,
+	on_blast = mesecon.on_blastnode,
 })
-
-minetest.register_craft({
-	output = 'mesecons_detector:node_detector_off',
-	recipe = {
-		{"default:steel_ingot", "group:mesecon_conductor_craftable", "default:steel_ingot"},
-		{"default:steel_ingot", "mesecons_luacontroller:luacontroller0000", "default:steel_ingot"},
-		{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
-	}
-})
-
 minetest.register_abm({
 	nodenames = {"mesecons_detector:node_detector_off"},
 	interval = 1,

mesecons_detector/mod.conf

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

mesecons_doors/depends.txt

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

mesecons_doors/init.lua

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

mesecons_extrawires/corner.lua

@@ -1,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",
+	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",
+	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},
+	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 @@
-local 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",
@@ -29,16 +27,19 @@ minetest.register_node("mesecons_extrawires:crossover_off", {
 		"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}},
+	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", {
@@ -53,16 +54,19 @@ minetest.register_node("mesecons_extrawires:crossover_01", {
 		"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}},
+	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", {
@@ -77,16 +81,19 @@ minetest.register_node("mesecons_extrawires:crossover_10", {
 		"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}},
+	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", {
@@ -101,31 +108,17 @@ minetest.register_node("mesecons_extrawires:crossover_on", {
 		"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}},
+	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

@@ -1 +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.
+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

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

mesecons_extrawires/doc/mese/description.html

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

mesecons_extrawires/doc/tjunction/description.html

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