Merge remote-tracking branch 'upstream/master'

This is a casual game, no need for formal voice.

.github/workflows/check-release.yml

@@ -0,0 +1,41 @@
+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 ./
+
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@main
+    - name: apt
+      run: sudo apt-get install -y luarocks
+    - name: busted install
+      run: luarocks install --local busted
+    - name: luacov install
+      run: luarocks install --local luacov
+    - name: mineunit install
+      run: luarocks install --server=https://luarocks.org/dev --local mineunit
+    - name: run mesecons tests
+      working-directory: ./mesecons/
+      run: $HOME/.luarocks/bin/mineunit -q
+    - name: run mesecons_mvps tests
+      working-directory: ./mesecons_mvps/
+      run: $HOME/.luarocks/bin/mineunit -q
+    - name: run mesecons_fpga tests
+      working-directory: ./mesecons_fpga/
+      run: $HOME/.luarocks/bin/mineunit -q
+    - name: run mesecons_luacontroller tests
+      working-directory: ./mesecons_luacontroller/
+      run: $HOME/.luarocks/bin/mineunit -q

.luacheckrc

@@ -0,0 +1,59 @@
+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"},
+}
+
+-- Test-specific stuff follows.
+
+local test_conf = {
+	read_globals = {
+		"assert",
+		"fixture",
+		"mineunit",
+		"Player",
+		"sourcefile",
+		"world",
+	},
+}
+files["*/spec/*.lua"] = test_conf
+files[".test_fixtures/*.lua"] = test_conf
+
+files[".test_fixtures/screwdriver.lua"] = {
+	globals = {"screwdriver"},
+}
+
+files[".test_fixtures/mesecons_fpga.lua"] = {
+	globals = {"minetest.register_on_player_receive_fields"},
+}

.test_fixtures/mesecons.lua

@@ -0,0 +1,156 @@
+mineunit("core")
+mineunit("server")
+mineunit("voxelmanip")
+
+mineunit:set_current_modname("mesecons")
+mineunit:set_modpath("mesecons", "../mesecons")
+sourcefile("../mesecons/init")
+
+-- Utility node: this conductor is used to test the connectivity and state of adjacent wires.
+do
+	local off_spec = {conductor = {
+		state = mesecon.state.off,
+		rules = mesecon.rules.alldirs,
+		onstate = "mesecons:test_conductor_on",
+	}}
+	local on_spec = {conductor = {
+		state = mesecon.state.on,
+		rules = mesecon.rules.alldirs,
+		offstate = "mesecons:test_conductor_off",
+	}}
+	mesecon.register_node("mesecons:test_conductor", {
+		description = "Test Conductor",
+	}, {mesecons = off_spec}, {mesecons = on_spec})
+end
+
+-- Utility node: this receptor is used to test power sources.
+do
+	local off_spec = {receptor = {
+		state = mesecon.state.off,
+		rules = mesecon.rules.alldirs,
+	}}
+	local on_spec = {receptor = {
+		state = mesecon.state.on,
+		rules = mesecon.rules.alldirs,
+	}}
+	mesecon.register_node("mesecons:test_receptor", {
+		description = "Test Receptor",
+	}, {mesecons = off_spec}, {mesecons = on_spec})
+end
+
+-- Utility node: this effector is used to test circuit outputs.
+do
+	-- This is a list of actions in the form {<kind>, <pos>},
+	-- where <kind> is "on", "off", or "overheat".
+	mesecon._test_effector_events = {}
+	local function action_on(pos, node)
+		table.insert(mesecon._test_effector_events, {"on", pos})
+		node.param2 = node.param2 % 64 + 128 -- Turn on bit 7
+		minetest.swap_node(pos, node)
+	end
+	local function action_off(pos, node)
+		table.insert(mesecon._test_effector_events, {"off", pos})
+		node.param2 = node.param2 % 64 -- Turn off bit 7
+		minetest.swap_node(pos, node)
+	end
+	local function action_change(pos, node, rule_name, new_state)
+		if mesecon.do_overheat(pos) then
+			table.insert(mesecon._test_effector_events, {"overheat", pos})
+			minetest.remove_node(pos)
+			return
+		end
+		-- Set the value of a bit in param2 according to the rule name and new state.
+		local bit = tonumber(rule_name.name, 2)
+		local bits_above = node.param2 - node.param2 % (bit * 2)
+		local bits_below = node.param2 % bit
+		local bits_flipped = new_state == mesecon.state.on and bit or 0
+		node.param2 = bits_above + bits_flipped + bits_below
+		minetest.swap_node(pos, node)
+	end
+	minetest.register_node("mesecons:test_effector", {
+		description = "Test Effector",
+		mesecons = {effector = {
+			action_on = action_on,
+			action_off = action_off,
+			action_change = action_change,
+			rules = {
+				{x =  1, y =  0, z =  0, name = "000001"},
+				{x = -1, y =  0, z =  0, name = "000010"},
+				{x =  0, y =  1, z =  0, name = "000100"},
+				{x =  0, y = -1, z =  0, name = "001000"},
+				{x =  0, y =  0, z =  1, name = "010000"},
+				{x =  0, y =  0, z = -1, name = "100000"},
+			}
+		}},
+	})
+end
+
+-- Utility node: this conductor is used to test rotation.
+do
+	local get_rules = mesecon.horiz_rules_getter({{x = 1, y = 0, z = 0}, {x = -1, y = 0, z = 0}})
+	local off_spec = {conductor = {
+		state = mesecon.state.off,
+		rules = get_rules,
+		onstate = "mesecons:test_conductor_rot_on",
+	}}
+	local on_spec = {conductor = {
+		state = mesecon.state.on,
+		rules = get_rules,
+		offstate = "mesecons:test_conductor_rot_off",
+	}}
+	mesecon.register_node("mesecons:test_conductor_rot", {
+		description = "Rotatable Test Conductor",
+		on_rotate = mesecon.on_rotate_horiz,
+	}, {mesecons = off_spec}, {mesecons = on_spec})
+end
+
+-- Utility node: this is used to test multiple conductors within a single node.
+do
+	local mesecons_spec = {conductor = {
+		rules = {
+			{{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}, {x = -1, y = 0, z = 0}},
+		},
+		states = {
+			"mesecons:test_multiconductor_off", "mesecons:test_multiconductor_001",
+			"mesecons:test_multiconductor_010", "mesecons:test_multiconductor_011",
+			"mesecons:test_multiconductor_100", "mesecons:test_multiconductor_101",
+			"mesecons:test_multiconductor_110", "mesecons:test_multiconductor_on",
+		},
+	}}
+	for _, state in ipairs(mesecons_spec.conductor.states) do
+		minetest.register_node(state, {
+			description = "Test Multiconductor",
+			mesecons = mesecons_spec,
+		})
+	end
+end
+
+mesecon._test_autoconnects = {}
+mesecon.register_autoconnect_hook("test", function(pos, node)
+	table.insert(mesecon._test_autoconnects, {pos, node})
+end)
+
+function mesecon._test_dig(pos)
+	local node = minetest.get_node(pos)
+	minetest.remove_node(pos)
+	mesecon.on_dignode(pos, node)
+end
+
+function mesecon._test_place(pos, node)
+	world.set_node(pos, node)
+	mesecon.on_placenode(pos, minetest.get_node(pos))
+end
+
+function mesecon._test_reset()
+	-- First let circuits settle by simulating many globalsteps.
+	for i = 1, 10 do
+		mineunit:execute_globalstep(60)
+	end
+	mesecon.queue.actions = {}
+	mesecon._test_effector_events = {}
+	mesecon._test_autoconnects = {}
+end
+
+mineunit:execute_globalstep(mesecon.setting("resumetime", 4) + 1)

.test_fixtures/mesecons_fpga.lua

@@ -0,0 +1,59 @@
+mineunit("player")
+
+fixture("mesecons")
+fixture("mesecons_gamecompat")
+
+local registered_on_player_receive_fields = {}
+local old_register_on_player_receive_fields = minetest.register_on_player_receive_fields
+function minetest.register_on_player_receive_fields(func)
+	old_register_on_player_receive_fields(func)
+	table.insert(registered_on_player_receive_fields, func)
+end
+
+mineunit:set_current_modname("mesecons_fpga")
+mineunit:set_modpath("mesecons_fpga", "../mesecons_fpga")
+sourcefile("../mesecons_fpga/init")
+
+local fpga_user = Player("mesecons_fpga_user")
+
+function mesecon._test_program_fpga(pos, program)
+	local node = minetest.get_node(pos)
+	assert.equal("mesecons_fpga:fpga", node.name:sub(1, 18))
+
+	local fields = {program = true}
+	for i, instr in ipairs(program) do
+		-- Translate the instruction into formspec fields.
+		local op1, act, op2, dst
+		if #instr == 3 then
+			act, op2, dst = unpack(instr)
+		else
+			assert.equal(4, #instr)
+			op1, act, op2, dst = unpack(instr)
+		end
+		fields[i .. "op1"] = op1
+		fields[i .. "act"] = (" "):rep(4 - #act) .. act
+		fields[i .. "op2"] = op2
+		fields[i .. "dst"] = dst
+	end
+
+	minetest.registered_nodes[node.name].on_rightclick(pos, node, fpga_user)
+
+	for _, func in ipairs(registered_on_player_receive_fields) do
+		if func(fpga_user, "mesecons:fpga", fields) then
+			break
+		end
+	end
+end
+
+function mesecon._test_copy_fpga_program(pos)
+	fpga_user:get_inventory():set_stack("main", 1, "mesecons_fpga:programmer")
+	local pt = {type = "node", under = vector.new(pos), above = vector.offset(pos, 0, 1, 0)}
+	fpga_user:do_place(pt)
+	return fpga_user:get_wielded_item()
+end
+
+function mesecon._test_paste_fpga_program(pos, tool)
+	fpga_user:get_inventory():set_stack("main", 1, tool)
+	local pt = {type = "node", under = vector.new(pos), above = vector.offset(pos, 0, 1, 0)}
+	fpga_user:do_use(pt)
+end

.test_fixtures/mesecons_gamecompat.lua

@@ -0,0 +1,5 @@
+fixture("mesecons")
+
+mineunit:set_current_modname("mesecons_gamecompat")
+mineunit:set_modpath("mesecons_gamecompat", "../mesecons_gamecompat")
+sourcefile("../mesecons_gamecompat/init")

.test_fixtures/mesecons_luacontroller.lua

@@ -0,0 +1,12 @@
+fixture("mesecons")
+fixture("mesecons_gamecompat")
+
+mineunit:set_current_modname("mesecons_luacontroller")
+mineunit:set_modpath("mesecons_luacontroller", "../mesecons_luacontroller")
+sourcefile("../mesecons_luacontroller/init")
+
+function mesecon._test_program_luac(pos, code)
+	local node = minetest.get_node(pos)
+	assert.equal("mesecons_luacontroller:luacontroller", node.name:sub(1, 36))
+	return minetest.registered_nodes[node.name].mesecons.luacontroller.set_program(pos, code)
+end

.test_fixtures/mesecons_mvps.lua

@@ -0,0 +1,45 @@
+mineunit("protection")
+
+fixture("mesecons")
+
+mineunit:set_current_modname("mesecons_mvps")
+mineunit:set_modpath("mesecons_mvps", "../mesecons_mvps")
+sourcefile("../mesecons_mvps/init")
+
+minetest.register_node("mesecons_mvps:test_stopper", {
+	description = "Test Stopper",
+})
+mesecon.register_mvps_stopper("mesecons_mvps:test_stopper")
+
+minetest.register_node("mesecons_mvps:test_stopper_cond", {
+	description = "Test Stopper (Conditional)",
+})
+mesecon.register_mvps_stopper("mesecons_mvps:test_stopper_cond", function(node)
+	return node.param2 == 0
+end)
+
+minetest.register_node("mesecons_mvps:test_sticky", {
+	description = "Test Sticky",
+	mvps_sticky = function(pos)
+		local connected = {}
+		for i, rule in ipairs(mesecon.rules.alldirs) do
+			connected[i] = vector.add(pos, rule)
+		end
+		return connected
+	end,
+})
+
+mesecon._test_moves = {}
+minetest.register_node("mesecons_mvps:test_on_move", {
+	description = "Test Moveable",
+	mesecon = {
+		on_mvps_move = function(pos, node, oldpos, meta)
+			table.insert(mesecon._test_moves, {pos, node, oldpos, meta})
+		end
+	},
+})
+local old_reset = mesecon._test_reset
+function mesecon._test_reset()
+	mesecon._test_moves = {}
+	old_reset()
+end

.test_fixtures/screwdriver.lua

@@ -0,0 +1,6 @@
+mineunit:set_current_modname("screwdriver")
+
+screwdriver = {}
+
+screwdriver.ROTATE_FACE = 1
+screwdriver.ROTATE_AXIS = 2

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.
 
@@ -74,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

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

mesecons/actionqueue.lua

@@ -29,7 +29,7 @@ local queue = mesecon.queue
 queue.actions = {} -- contains all ActionQueue actions
 
 function queue:add_function(name, func)
-	queue.funcs[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
@@ -51,17 +51,17 @@ function queue:add_action(pos, func, params, time, overwritecheck, priority)
 
 	 -- check if old action has to be overwritten / removed:
 	if overwritecheck then
-		for i, ac in ipairs(queue.actions) do
+		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(queue.actions, i)
+				table.remove(self.actions, i)
 				break
 			end
 		end
 	end
 
-	table.insert(queue.actions, action)
+	table.insert(self.actions, action)
 end
 
 -- execute the stored functions on a globalstep
@@ -133,8 +133,8 @@ end
 function queue:execute(action)
 	-- ignore if action queue function name doesn't exist,
 	-- (e.g. in case the action queue savegame was written by an old mesecons version)
-	if queue.funcs[action.func] then
-		queue.funcs[action.func](action.pos, unpack(action.params))
+	if self.funcs[action.func] then
+		self.funcs[action.func](action.pos, unpack(action.params))
 	end
 end
 

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

@@ -99,7 +99,6 @@ mesecon.queue:add_function("receptor_off", function (pos, rules)
 		local rulenames = mesecon.rules_link_rule_all(pos, rule)
 		for _, rulename in ipairs(rulenames) do
 			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
@@ -118,8 +117,6 @@ function mesecon.receptor_off(pos, rules)
 end
 
 
-print("[OK] Mesecons")
-
 -- Deprecated stuff
 -- To be removed in future releases
 dofile(minetest.get_modpath("mesecons").."/legacy.lua");

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,14 +535,19 @@ 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
 
 	for _, sig in ipairs(signals) do
-		mesecon.changesignal(sig.pos, sig.node, sig.link, mesecon.state.off, sig.depth)
-		if mesecon.is_effector_on(sig.node.name) and not mesecon.is_powered(sig.pos) then
-			mesecon.deactivate(sig.pos, sig.node, sig.link, sig.depth)
+		-- If sig.depth is 1, it has not yet been checked that the power source is actually off.
+		if sig.depth > 1 or not mesecon.is_powered(sig.pos, sig.link) then
+			mesecon.changesignal(sig.pos, sig.node, sig.link, mesecon.state.off, sig.depth)
+			if mesecon.is_effector_on(sig.node.name) and not mesecon.is_powered(sig.pos) then
+				mesecon.deactivate(sig.pos, sig.node, sig.link, sig.depth)
+			end
 		end
 	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/locale/mesecons.de.tr

@@ -0,0 +1,3 @@
+# textdomain: mesecons
+
+Mesecons=Mesecons

mesecons/locale/mesecons.eo.tr

@@ -0,0 +1,4 @@
+# textdomain: mesecons
+
+### oldwires.lua ###
+Mesecons=Mesekonduktilo

mesecons/locale/template.txt

@@ -0,0 +1,4 @@
+# textdomain: mesecons
+
+### oldwires.lua ###
+Mesecons=

mesecons/mod.conf

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

mesecons/oldwires.lua

@@ -1,3 +1,5 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
 minetest.register_node("mesecons:mesecon_off", {
 	drawtype = "raillike",
 	tiles = {"jeija_mesecon_off.png", "jeija_mesecon_curved_off.png", "jeija_mesecon_t_junction_off.png", "jeija_mesecon_crossing_off.png"},
@@ -11,7 +13,7 @@ minetest.register_node("mesecons:mesecon_off", {
 		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= S("Mesecons"),
 	mesecons = {conductor={
 		state = mesecon.state.off,
 		onstate = "mesecons:mesecon_on"

mesecons/presets.lua

@@ -16,9 +16,9 @@ mesecon.rules.default = {
 	{x =  0, y = -1, z = -1},
 }
 
-mesecon.rules.floor = mesecon.mergetable(mesecon.rules.default, {{x = 0, y = -1, z = 0}})
+mesecon.rules.floor = mesecon.merge_rule_sets(mesecon.rules.default, {{x = 0, y = -1, z = 0}})
 
-mesecon.rules.pplate = mesecon.mergetable(mesecon.rules.floor, {{x = 0, y = -2, z = 0}})
+mesecon.rules.pplate = mesecon.merge_rule_sets(mesecon.rules.floor, {{x = 0, y = -2, z = 0}})
 
 mesecon.rules.buttonlike = {
 	{x = 1,  y =  0, z =  0},
@@ -64,6 +64,8 @@ local rules_buttonlike = {
 }
 
 local function rules_from_dir(ruleset, dir)
+	if not dir then return {} end
+
 	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

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,18 +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
-			node.name = mesecon.get_conductor_off(node)
-			minetest.swap_node(pos, node)
+			mesecon.vm_commit()
 		end
 	end
 
@@ -63,7 +66,7 @@ mesecon.on_dignode = function(pos, node)
 	mesecon.execute_autoconnect_hooks_queue(pos, node)
 end
 
-function mesecon.on_blastnode(pos, intensity)
+function mesecon.on_blastnode(pos)
 	local node = minetest.get_node(pos)
 	minetest.remove_node(pos)
 	mesecon.on_dignode(pos, node)

mesecons/spec/action_spec.lua

@@ -0,0 +1,62 @@
+require("mineunit")
+
+fixture("mesecons")
+
+describe("action queue", function()
+	local layout = {
+		{{x =  1, y = 0, z = 0}, "mesecons:test_receptor_off"},
+		{{x =  0, y = 0, z = 0}, "mesecons:test_conductor_off"},
+		{{x = -1, y = 0, z = 0}, "mesecons:test_conductor_off"},
+		{{x =  0, y = 1, z = 0}, "mesecons:test_effector"},
+		{{x = -1, y = 1, z = 0}, "mesecons:test_effector"},
+	}
+
+	before_each(function()
+		world.layout(layout)
+	end)
+
+	after_each(function()
+		mesecon._test_reset()
+		world.clear()
+	end)
+
+	it("executes in order", function()
+		world.set_node(layout[1][1], "mesecons:test_receptor_on")
+		mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
+		mineunit:execute_globalstep() -- Execute receptor_on action
+		mineunit:execute_globalstep() -- Execute activate/change actions
+		assert.equal(2, #mesecon._test_effector_events)
+		assert.same({"on", layout[4][1]}, mesecon._test_effector_events[1])
+		assert.same({"on", layout[5][1]}, mesecon._test_effector_events[2])
+
+		world.set_node(layout[1][1], "mesecons:test_receptor_off")
+		mesecon.receptor_off(layout[1][1], mesecon.rules.alldirs)
+		mineunit:execute_globalstep() -- Execute receptor_off action
+		mineunit:execute_globalstep() -- Execute deactivate/change actions
+		assert.equal(4, #mesecon._test_effector_events)
+		assert.same({"off", layout[4][1]}, mesecon._test_effector_events[3])
+		assert.same({"off", layout[5][1]}, mesecon._test_effector_events[4])
+	end)
+
+	it("discards outdated/overwritten node events", function()
+		world.set_node(layout[1][1], "mesecons:test_receptor_on")
+		mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
+		world.set_node(layout[1][1], "mesecons:test_receptor_off")
+		mesecon.receptor_off(layout[1][1], mesecon.rules.alldirs)
+		mineunit:execute_globalstep() -- Execute receptor_off action
+		mineunit:execute_globalstep() -- Execute deactivate/change actions
+		assert.equal(0, #mesecon._test_effector_events)
+	end)
+
+	it("delays actions", function()
+		world.set_node(layout[1][1], "mesecons:test_receptor_on")
+		mesecon.queue:add_action(layout[1][1], "receptor_on", {mesecon.rules.alldirs}, 1, nil)
+		mineunit:execute_globalstep(0.1)
+		mineunit:execute_globalstep(1)
+		assert.equal(0, #mesecon._test_effector_events)
+		mineunit:execute_globalstep() -- Execute receptor_on action
+		assert.equal(0, #mesecon._test_effector_events)
+		mineunit:execute_globalstep() -- Execute activate/change actions
+		assert.equal(2, #mesecon._test_effector_events)
+	end)
+end)

mesecons/spec/mineunit.conf

@@ -0,0 +1 @@
+fixture_paths = {"../.test_fixtures"}

mesecons/spec/service_spec.lua

@@ -0,0 +1,192 @@
+require("mineunit")
+
+fixture("mesecons")
+fixture("screwdriver")
+
+describe("placement/digging service", function()
+	local layout = {
+		{{x =  1, y = 0, z = 0}, "mesecons:test_receptor_on"},
+		{{x =  0, y = 0, z = 0}, "mesecons:test_conductor_on"},
+		{{x = -1, y = 0, z = 0}, "mesecons:test_conductor_on"},
+		{{x =  0, y = 1, z = 0}, "mesecons:test_effector"},
+		{{x = -2, y = 0, z = 0}, "mesecons:test_effector"},
+		{{x =  2, y = 0, z = 0}, "mesecons:test_effector"},
+	}
+
+	before_each(function()
+		world.layout(layout)
+	end)
+
+	after_each(function()
+		mesecon._test_reset()
+		world.clear()
+	end)
+
+	it("updates components when a receptor changes", function()
+		-- Dig then replace a receptor and check that the connected effectors changed.
+
+		mesecon._test_dig(layout[1][1])
+		mineunit:execute_globalstep() -- Execute receptor_off action
+		assert.equal("mesecons:test_conductor_off", world.get_node(layout[2][1]).name)
+		mineunit:execute_globalstep() -- Execute deactivate/change actions
+		assert.equal(3, #mesecon._test_effector_events)
+
+		mesecon._test_place(layout[1][1], "mesecons:test_receptor_on")
+		mineunit:execute_globalstep() -- Execute receptor_on action
+		assert.equal("mesecons:test_conductor_on", world.get_node(layout[2][1]).name)
+		mineunit:execute_globalstep() -- Execute activate/change action
+		assert.equal(6, #mesecon._test_effector_events)
+	end)
+
+	it("updates components when a conductor changes", function()
+		-- Dig then replace a powered conductor and check that the connected effectors changed.
+
+		mesecon._test_dig(layout[2][1])
+		mineunit:execute_globalstep() -- Execute receptor_off action
+		assert.equal("mesecons:test_conductor_off", world.get_node(layout[3][1]).name)
+		mineunit:execute_globalstep() -- Execute deactivate/change actions
+		assert.equal(2, #mesecon._test_effector_events)
+
+		mesecon._test_place(layout[2][1], "mesecons:test_conductor_off")
+		assert.equal("mesecons:test_conductor_on", world.get_node(layout[2][1]).name)
+		assert.equal("mesecons:test_conductor_on", world.get_node(layout[3][1]).name)
+		mineunit:execute_globalstep() -- Execute activate/change actions
+		assert.equal(4, #mesecon._test_effector_events)
+	end)
+
+	it("updates effectors on placement", function()
+		local pos = {x = 0, y = 0, z = 1}
+		mesecon._test_place(pos, "mesecons:test_effector")
+		mineunit:execute_globalstep() -- Execute activate/change actions
+		assert.equal(tonumber("10100000", 2), world.get_node(pos).param2)
+	end)
+
+	it("updates multiconductors on placement", function()
+		local pos = {x = 0, y = 0, z = 1}
+		mesecon._test_place(pos, "mesecons:test_multiconductor_off")
+		assert.equal("mesecons:test_multiconductor_010", world.get_node(pos).name)
+	end)
+
+	it("turns off conductors on placement", function()
+		local pos = {x = 3, y = 0, z = 0}
+		mesecon._test_place(pos, "mesecons:test_conductor_on")
+		assert.equal("mesecons:test_conductor_off", world.get_node(pos).name)
+	end)
+
+	it("turns off multiconductors on placement", function()
+		local pos = {x = 3, y = 0, z = 0}
+		mesecon._test_place(pos, "mesecons:test_multiconductor_on")
+		assert.equal("mesecons:test_multiconductor_off", world.get_node(pos).name)
+	end)
+
+	it("triggers autoconnect hooks", function()
+		mesecon._test_dig(layout[2][1])
+		mineunit:execute_globalstep() -- Execute delayed hook
+		assert.equal(1, #mesecon._test_autoconnects)
+
+		mesecon._test_place(layout[2][1], layout[2][2])
+		assert.equal(2, #mesecon._test_autoconnects)
+	end)
+end)
+
+describe("overheating service", function()
+	local layout = {
+		{{x = 0, y = 0, z = 0}, "mesecons:test_receptor_off"},
+		{{x = 1, y = 0, z = 0}, "mesecons:test_effector"},
+		{{x = 2, y = 0, z = 0}, "mesecons:test_receptor_on"},
+	}
+
+	before_each(function()
+		world.layout(layout)
+	end)
+
+	after_each(function()
+		mesecon._test_reset()
+		world.clear()
+	end)
+
+	it("tracks heat", function()
+		mesecon.do_overheat(layout[2][1])
+		assert.equal(1, mesecon.get_heat(layout[2][1]))
+		mesecon.do_cooldown(layout[2][1])
+		assert.equal(0, mesecon.get_heat(layout[2][1]))
+	end)
+
+	it("cools over time", function()
+		mesecon.do_overheat(layout[2][1])
+		assert.equal(1, mesecon.get_heat(layout[2][1]))
+		mineunit:execute_globalstep(60)
+		mineunit:execute_globalstep(60)
+		mineunit:execute_globalstep(60)
+		assert.equal(0, mesecon.get_heat(layout[2][1]))
+	end)
+
+	it("tracks movement", function()
+		local oldpos = layout[2][1]
+		local pos = vector.offset(oldpos, 0, 1, 0)
+		mesecon.do_overheat(oldpos)
+		mesecon.move_hot_nodes({{pos = pos, oldpos = oldpos}})
+		assert.equal(0, mesecon.get_heat(oldpos))
+		assert.equal(1, mesecon.get_heat(pos))
+	end)
+
+	it("causes overheating", function()
+		-- Switch the first receptor on and off until it overheats/breaks a receptor.
+		repeat
+			if mesecon.flipstate(layout[1][1], minetest.get_node(layout[1][1])) == "on" then
+				mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
+			else
+				mesecon.receptor_off(layout[1][1], mesecon.rules.alldirs)
+			end
+			mineunit:execute_globalstep(0) -- Execute receptor_on/receptor_off/activate/deactivate/change actions
+		until minetest.get_node(layout[2][1]).name ~= "mesecons:test_effector"
+		assert.same({"overheat", layout[2][1]}, mesecon._test_effector_events[#mesecon._test_effector_events])
+		assert.equal(0, mesecon.get_heat(layout[2][1]))
+	end)
+end)
+
+describe("screwdriver service", function()
+	local layout = {
+		{{x =  0, y = 0, z =  0}, "mesecons:test_conductor_rot_on"},
+		{{x =  1, y = 0, z =  0}, "mesecons:test_receptor_on"},
+		{{x = -1, y = 0, z =  0}, "mesecons:test_conductor_on"},
+		{{x =  0, y = 0, z =  1}, "mesecons:test_receptor_on"},
+		{{x =  0, y = 0, z = -1}, "mesecons:test_conductor_off"},
+	}
+
+	local function rotate(new_param2)
+		local pos = layout[1][1]
+		local node = world.get_node(pos)
+		local on_rotate = minetest.registered_nodes[node.name].on_rotate
+		on_rotate(pos, node, nil, screwdriver.ROTATE_FACE, new_param2)
+	end
+
+	before_each(function()
+		world.layout(layout)
+	end)
+
+	after_each(function()
+		mesecon._test_reset()
+		world.clear()
+	end)
+
+	it("updates conductors", function()
+		-- Rotate a conductor and see that the circuit state changes.
+		rotate(1)
+		mineunit:execute_globalstep() -- Execute receptor_off action
+		assert.equal("mesecons:test_conductor_off", world.get_node(layout[3][1]).name)
+		assert.equal("mesecons:test_conductor_on", world.get_node(layout[5][1]).name)
+		rotate(2)
+		mineunit:execute_globalstep() -- Execute receptor_off action
+		assert.equal("mesecons:test_conductor_on", world.get_node(layout[3][1]).name)
+		assert.equal("mesecons:test_conductor_off", world.get_node(layout[5][1]).name)
+		rotate(3)
+		mineunit:execute_globalstep() -- Execute receptor_off action
+		assert.equal("mesecons:test_conductor_off", world.get_node(layout[3][1]).name)
+		assert.equal("mesecons:test_conductor_on", world.get_node(layout[5][1]).name)
+		rotate(0)
+		mineunit:execute_globalstep() -- Execute receptor_off action
+		assert.equal("mesecons:test_conductor_on", world.get_node(layout[3][1]).name)
+		assert.equal("mesecons:test_conductor_off", world.get_node(layout[5][1]).name)
+	end)
+end)

mesecons/spec/state_spec.lua

@@ -0,0 +1,147 @@
+require("mineunit")
+
+fixture("mesecons")
+
+describe("state", function()
+	local layout = {
+		{{x =  1, y =  0, z = 0}, "mesecons:test_receptor_off"},
+		{{x =  0, y =  1, z = 0}, "mesecons:test_receptor_off"},
+		{{x =  0, y =  0, z = 0}, "mesecons:test_conductor_off"},
+		{{x = -1, y =  0, z = 0}, "mesecons:test_effector"},
+		{{x =  2, y =  0, z = 0}, "mesecons:test_effector"},
+		{{x =  0, y = -1, z = 0}, "mesecons:test_effector"},
+	}
+
+	before_each(function()
+		world.layout(layout)
+	end)
+
+	after_each(function()
+		mesecon._test_reset()
+		world.clear()
+	end)
+
+	it("turns on", function()
+		world.set_node(layout[1][1], "mesecons:test_receptor_on")
+		mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
+		mineunit:execute_globalstep() -- Execute receptor_on action
+		mineunit:execute_globalstep() -- Execute activate/change actions
+		assert.equal("mesecons:test_conductor_on", world.get_node(layout[3][1]).name)
+		assert.equal(tonumber("10000001", 2), world.get_node(layout[4][1]).param2)
+		assert.equal(tonumber("10000010", 2), world.get_node(layout[5][1]).param2)
+		assert.equal(tonumber("10000100", 2), world.get_node(layout[6][1]).param2)
+
+		world.set_node(layout[2][1], "mesecons:test_receptor_on")
+		mesecon.receptor_on(layout[2][1], mesecon.rules.alldirs)
+		mineunit:execute_globalstep() -- Execute receptor_on action
+		mineunit:execute_globalstep() -- Execute activate/change actions
+		assert.equal("mesecons:test_conductor_on", world.get_node(layout[3][1]).name)
+		assert.equal(tonumber("10000001", 2), world.get_node(layout[4][1]).param2)
+		assert.equal(tonumber("10000010", 2), world.get_node(layout[5][1]).param2)
+		assert.equal(tonumber("10000100", 2), world.get_node(layout[6][1]).param2)
+	end)
+
+	it("turns off", function()
+		world.set_node(layout[1][1], "mesecons:test_receptor_on")
+		world.set_node(layout[2][1], "mesecons:test_receptor_on")
+		mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
+		mesecon.receptor_on(layout[2][1], mesecon.rules.alldirs)
+		mineunit:execute_globalstep() -- Execute receptor_on actions
+
+		world.set_node(layout[1][1], "mesecons:test_receptor_off")
+		mesecon.receptor_off(layout[1][1], mesecon.rules.alldirs)
+		mineunit:execute_globalstep() -- Execute receptor_off and activate/change actions
+		mineunit:execute_globalstep() -- Execute deactivate/change actions
+		assert.equal("mesecons:test_conductor_on", world.get_node(layout[3][1]).name)
+		assert.equal(tonumber("10000001", 2), world.get_node(layout[4][1]).param2)
+		assert.equal(tonumber("00000000", 2), world.get_node(layout[5][1]).param2)
+		assert.equal(tonumber("10000100", 2), world.get_node(layout[6][1]).param2)
+
+		world.set_node(layout[2][1], "mesecons:test_receptor_off")
+		mesecon.receptor_off(layout[2][1], mesecon.rules.alldirs)
+		mineunit:execute_globalstep() -- Execute receptor_off action
+		mineunit:execute_globalstep() -- Execute deactivate/change actions
+		assert.equal("mesecons:test_conductor_off", world.get_node(layout[3][1]).name)
+		assert.equal(tonumber("00000000", 2), world.get_node(layout[4][1]).param2)
+		assert.equal(tonumber("00000000", 2), world.get_node(layout[5][1]).param2)
+		assert.equal(tonumber("00000000", 2), world.get_node(layout[6][1]).param2)
+	end)
+end)
+
+describe("rotation", function()
+	local layout = {
+		{{x =  0, y = 0, z =  0}, "mesecons:test_receptor_off"},
+		{{x =  1, y = 0, z =  0}, {name = "mesecons:test_conductor_rot_off", param2 = 0}},
+		{{x =  0, y = 0, z =  1}, {name = "mesecons:test_conductor_rot_off", param2 = 1}},
+		{{x = -1, y = 0, z =  0}, {name = "mesecons:test_conductor_rot_off", param2 = 2}},
+		{{x =  0, y = 0, z = -1}, {name = "mesecons:test_conductor_rot_off", param2 = 3}},
+	}
+
+	before_each(function()
+		for _, entry in ipairs(layout) do
+			world.set_node(entry[1], entry[2])
+		end
+	end)
+
+	after_each(function()
+		mesecon._test_reset()
+		world.clear()
+	end)
+
+	it("works", function()
+		world.set_node(layout[1][1], "mesecons:test_receptor_on")
+		mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
+		mineunit:execute_globalstep() -- Execute receptor_on action
+		assert.equal("mesecons:test_conductor_rot_on", world.get_node(layout[2][1]).name)
+		assert.equal("mesecons:test_conductor_rot_on", world.get_node(layout[3][1]).name)
+		assert.equal("mesecons:test_conductor_rot_on", world.get_node(layout[4][1]).name)
+		assert.equal("mesecons:test_conductor_rot_on", world.get_node(layout[5][1]).name)
+	end)
+end)
+
+describe("multiconductor", function()
+	local layout = {
+		{{x =  1, y = 0, z =  0}, "mesecons:test_receptor_off"},
+		{{x =  0, y = 1, z =  0}, "mesecons:test_receptor_off"},
+		{{x =  0, y = 0, z =  1}, "mesecons:test_receptor_off"},
+		{{x =  0, y = 0, z =  0}, "mesecons:test_multiconductor_off"},
+	}
+
+	before_each(function()
+		world.layout(layout)
+	end)
+
+	after_each(function()
+		world.clear()
+		mesecon._test_reset()
+	end)
+
+	it("separates its subparts", function()
+		world.set_node(layout[1][1], "mesecons:test_receptor_on")
+		mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
+		mineunit:execute_globalstep() -- Execute receptor_on action
+		assert.equal("mesecons:test_multiconductor_001", world.get_node(layout[4][1]).name)
+
+		world.set_node(layout[2][1], "mesecons:test_receptor_on")
+		mesecon.receptor_on(layout[2][1], mesecon.rules.alldirs)
+		mineunit:execute_globalstep() -- Execute receptor_on action
+		assert.equal("mesecons:test_multiconductor_011", world.get_node(layout[4][1]).name)
+
+		world.set_node(layout[3][1], "mesecons:test_receptor_on")
+		mesecon.receptor_on(layout[3][1], mesecon.rules.alldirs)
+		mineunit:execute_globalstep() -- Execute receptor_on action
+		assert.equal("mesecons:test_multiconductor_on", world.get_node(layout[4][1]).name)
+	end)
+
+	it("loops through itself", function()
+		-- Make a loop.
+		world.set_node({x = 0, y = -1, z = 0}, "mesecons:test_conductor_off")
+		world.set_node({x = -1, y = -1, z = 0}, "mesecons:test_conductor_off")
+		world.set_node({x = -1, y = 0, z = 0}, "mesecons:test_conductor_off")
+
+		world.set_node(layout[1][1], "mesecons:test_receptor_on")
+		mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
+		mineunit:execute_globalstep() -- Execute receptor_on action
+		assert.equal("mesecons:test_multiconductor_101", world.get_node(layout[4][1]).name)
+	end)
+end)

mesecons/util.lua

@@ -6,6 +6,24 @@ 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 = {}
@@ -54,7 +72,28 @@ function mesecon.rotate_rules_up(rules)
 	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)
 --[[
@@ -164,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
 
@@ -213,8 +254,9 @@ function mesecon.cmpAny(t1, t2)
 	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
@@ -227,6 +269,32 @@ 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
@@ -234,8 +302,8 @@ function mesecon.register_node(name, spec_common, spec_off, spec_on)
 	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)
@@ -257,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()
@@ -266,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
@@ -288,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
@@ -305,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
@@ -313,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.
@@ -332,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
@@ -344,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
 
@@ -398,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_blinkyplant/init.lua

@@ -1,5 +1,7 @@
 -- The BLINKY_PLANT
 
+local S = minetest.get_translator(minetest.get_current_modname())
+
 local toggle_timer = function (pos)
 	local timer = minetest.get_node_timer(pos)
 	if timer:is_started() then
@@ -20,19 +22,25 @@ local on_timer = function (pos)
 end
 
 mesecon.register_node("mesecons_blinkyplant:blinky_plant", {
-	description="Blinky Plant",
+	description= S("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"},

mesecons_blinkyplant/locale/mesecons_blinkyplant.de.tr

@@ -0,0 +1,2 @@
+# textdomain: mesecons_blinkyplant
+Blinky Plant=Blinkpflanze

mesecons_blinkyplant/locale/mesecons_blinkyplant.eo.tr

@@ -0,0 +1,4 @@
+# textdomain: mesecons_blinkyplant
+
+### init.lua ###
+Blinky Plant=Palpebruma Planto

mesecons_blinkyplant/locale/template.txt

@@ -0,0 +1,4 @@
+# textdomain: mesecons_blinkyplant
+
+### init.lua ###
+Blinky Plant=

mesecons_blinkyplant/mod.conf

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

mesecons_button/init.lua

@@ -1,6 +1,7 @@
 -- WALL BUTTON
 -- A button that when pressed emits power for 1 second
 -- and then turns off again
+local S = minetest.get_translator(minetest.get_current_modname())
 
 mesecon.button_turnoff = function (pos)
 	local node = minetest.get_node(pos)
@@ -13,16 +14,19 @@ mesecon.button_turnoff = function (pos)
 	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,
@@ -42,14 +46,14 @@ minetest.register_node("mesecons_button:button_off", {
 	}
 	},
 	groups = {dig_immediate=2, mesecon_needs_receiver = 1},
-	description = "Button",
+	description = S("Button"),
 	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 }, 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
@@ -66,7 +70,8 @@ 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,
@@ -88,8 +93,8 @@ 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(),
+	description = S("Button"),
+	sounds = mesecon.node_sound.stone,
 	mesecons = {receptor = {
 		state = mesecon.state.on,
 		rules = mesecon.rules.buttonlike_get
@@ -101,6 +106,6 @@ minetest.register_node("mesecons_button:button_on", {
 minetest.register_craft({
 	output = "mesecons_button:button_off 2",
 	recipe = {
-		{"group:mesecon_conductor_craftable","default:stone"},
+		{"group:mesecon_conductor_craftable","mesecons_gamecompat:stone"},
 	}
 })

mesecons_button/locale/mesecons_button.de.tr

@@ -0,0 +1,2 @@
+# textdomain: mesecons_button
+Button=Taster

mesecons_button/locale/mesecons_button.eo.tr

@@ -0,0 +1,4 @@
+# textdomain: mesecons_button
+
+### init.lua ###
+Button=Butono

mesecons_button/locale/template.txt

@@ -0,0 +1,4 @@
+# textdomain: mesecons_button
+
+### init.lua ###
+Button=

mesecons_button/mod.conf

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

mesecons_commandblock/init.lua

@@ -1,6 +1,8 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
 minetest.register_chatcommand("say", {
 	params = "<text>",
-	description = "Say <text> as the server",
+	description = S("Say <text> as the server"),
 	privs = {server=true},
 	func = function(name, param)
 		minetest.chat_send_all(name .. ": " .. param)
@@ -9,7 +11,8 @@ minetest.register_chatcommand("say", {
 
 minetest.register_chatcommand("tell", {
 	params = "<name> <text>",
-	description = "Say <text> to <name> privately",
+	description = S("Say <text> to <name> privately"),
+	privs = {shout=true},
 	func = function(name, param)
 		local found, _, target, message = param:find("^([^%s]+)%s+(.*)$")
 		if found == nil then
@@ -25,7 +28,7 @@ minetest.register_chatcommand("tell", {
 
 minetest.register_chatcommand("hp", {
 	params = "<name> <value>",
-	description = "Set health of <name> to <value> hitpoints",
+	description = S("Set health of <name> to <value> hitpoints"),
 	privs = {ban=true},
 	func = function(name, param)
 		local found, _, target, value = param:find("^([^%s]+)%s+(%d+)$")
@@ -78,7 +81,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
@@ -179,7 +182,7 @@ local function can_dig(pos, player)
 end
 
 minetest.register_node("mesecons_commandblock:commandblock_off", {
-	description = "Command Block",
+	description = S("Command Block"),
 	tiles = {"jeija_commandblock_off.png"},
 	inventory_image = minetest.inventorycube("jeija_commandblock_off.png"),
 	is_ground_content = false,
@@ -188,7 +191,7 @@ minetest.register_node("mesecons_commandblock:commandblock_off", {
 	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
 	}},
@@ -205,7 +208,7 @@ 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
 	}},

mesecons_commandblock/locale/mesecons_commandblock.de.tr

@@ -0,0 +1,5 @@
+# textdomain: mesecons_commandblock
+Say <text> as the server=<Text> als Server sagen
+Say <text> to <name> privately=<Text> an <Name> privat senden
+Set health of <name> to <value> hitpoints=Gesundheit von <Name> auf <Wert> Trefferpunkte setzen
+Command Block=Befehlsblock

mesecons_commandblock/locale/mesecons_commandblock.eo.tr

@@ -0,0 +1,7 @@
+# textdomain: mesecons_commandblock
+
+### init.lua ###
+Say <text> as the server=Diru <teksto> kiel la servilo
+Say <text> to <name> privately=Diru <teksto> al <nomo> private
+Set health of <name> to <value> hitpoints=Agordu sanon de <nomo> al <valoro>
+Command Block=Komando-Bloko

mesecons_commandblock/locale/template.txt

@@ -0,0 +1,7 @@
+# textdomain: mesecons_commandblock
+
+### init.lua ###
+Say <text> as the server=
+Say <text> to <name> privately=
+Set health of <name> to <value> hitpoints=
+Command Block=

mesecons_commandblock/mod.conf

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

mesecons_delayer/init.lua

@@ -1,19 +1,9 @@
--- 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 S = minetest.get_translator(minetest.get_current_modname())
 
-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
+-- Function that get the input/output rules of the delayer
+local delayer_get_output_rules = mesecon.horiz_rules_getter({{x = 1, y = 0, z = 0}})
+
+local delayer_get_input_rules = mesecon.horiz_rules_getter({{x = -1, y = 0, z = 0}})
 
 -- Functions that are called after the delay time
 
@@ -54,6 +44,7 @@ local boxes = {
 -- Delayer definition defaults
 local def = {
 	drawtype = "nodebox",
+	use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "opaque" or nil,
 	walkable = true,
 	selection_box = {
 		type = "fixed",
@@ -68,7 +59,7 @@ local def = {
 	sunlight_propagates = true,
 	is_ground_content = false,
 	delayer_time = delaytime[i],
-	sounds = default.node_sound_stone_defaults(),
+	sounds = mesecon.node_sound.stone,
 	on_blast = mesecon.on_blastnode,
 	drop = "mesecons_delayer:delayer_off_1",
 }
@@ -80,7 +71,7 @@ if i > 1 then
 end
 
 local off_state = {
-	description = "Delayer",
+	description = S("Delayer"),
 	tiles = {
 		"mesecons_delayer_off_"..tostring(i)..".png",
 		"mesecons_delayer_bottom.png",
@@ -93,7 +84,7 @@ local off_state = {
 	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()) then
+		if minetest.is_protected(pos, puncher and puncher:get_player_name() or "") then
 			return
 		end
 
@@ -123,7 +114,7 @@ minetest.register_node("mesecons_delayer:delayer_off_"..tostring(i), off_state)
 
 -- Activated delayer definition defaults
 local on_state = {
-	description = "You hacker you",
+	description = S("You hacker you"),
 	tiles = {
 		"mesecons_delayer_on_"..tostring(i)..".png",
 		"mesecons_delayer_bottom.png",
@@ -134,7 +125,7 @@ local on_state = {
 	},
 	groups = {bendy = 2, snappy = 1, dig_immediate = 2, not_in_creative_inventory = 1},
 	on_punch = function(pos, node, puncher)
-		if minetest.is_protected(pos, puncher and puncher:get_player_name()) then
+		if minetest.is_protected(pos, puncher and puncher:get_player_name() or "") then
 			return
 		end
 
@@ -168,6 +159,6 @@ 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"},
+		{"mesecons_gamecompat:cobble","mesecons_gamecompat:cobble", "mesecons_gamecompat:cobble"},
 	}
 })

mesecons_delayer/locale/mesecons_delayer.de.tr

@@ -0,0 +1,3 @@
+# textdomain: mesecons_delayer
+Delayer=Verzögerer
+You hacker you=Du Hacker, Du

mesecons_delayer/locale/mesecons_delayer.eo.tr

@@ -0,0 +1,5 @@
+# textdomain: mesecons_delayer
+
+### init.lua ###
+Delayer=Prokrasto
+You hacker you=Vi hakisto

mesecons_delayer/locale/template.txt

@@ -0,0 +1,5 @@
+# textdomain: mesecons_delayer
+
+### init.lua ###
+Delayer=
+You hacker you=

mesecons_delayer/mod.conf

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

mesecons_detector/init.lua

@@ -1,3 +1,7 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
+local side_texture = mesecon.texture.steel_block or "mesecons_detector_side.png"
+
 local GET_COMMAND = "GET"
 
 -- Object detector
@@ -12,7 +16,7 @@ local function object_detector_make_formspec(pos)
 		"button_exit[7,0.75;2,3;;Save]")
 end
 
-local function object_detector_on_receive_fields(pos, formname, fields, sender)
+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
@@ -53,7 +57,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)
@@ -64,25 +68,25 @@ 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",
+	description= S("Player Detector"),
 	mesecons = {receptor = {
 		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(),
+	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,
@@ -94,7 +98,7 @@ 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(),
+	sounds = mesecon.node_sound.stone,
 	digiline = object_detector_digiline,
 	on_blast = mesecon.on_blastnode,
 })
@@ -102,18 +106,18 @@ minetest.register_node("mesecons_detector:object_detector_on", {
 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"},
+		{"mesecons_gamecompat:steel_ingot", "mesecons_gamecompat:steel_ingot", "mesecons_gamecompat:steel_ingot"},
+		{"mesecons_gamecompat:steel_ingot", "mesecons_luacontroller:luacontroller0000", "mesecons_gamecompat:steel_ingot"},
+		{"mesecons_gamecompat:steel_ingot", "group:mesecon_conductor_craftable", "mesecons_gamecompat:steel_ingot"},
 	}
 })
 
 minetest.register_craft({
 	output = 'mesecons_detector:object_detector_off',
 	recipe = {
-		{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
-		{"default:steel_ingot", "mesecons_microcontroller:microcontroller0000", "default:steel_ingot"},
-		{"default:steel_ingot", "group:mesecon_conductor_craftable", "default:steel_ingot"},
+		{"mesecons_gamecompat:steel_ingot", "mesecons_gamecompat:steel_ingot", "mesecons_gamecompat:steel_ingot"},
+		{"mesecons_gamecompat:steel_ingot", "mesecons_microcontroller:microcontroller0000", "mesecons_gamecompat:steel_ingot"},
+		{"mesecons_gamecompat:steel_ingot", "group:mesecon_conductor_craftable", "mesecons_gamecompat:steel_ingot"},
 	}
 })
 
@@ -156,7 +160,7 @@ local function node_detector_make_formspec(pos)
 		"button_exit[7,0.75;2,3;;Save]")
 end
 
-local function node_detector_on_receive_fields(pos, fieldname, fields, sender)
+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
@@ -238,43 +242,26 @@ local node_detector_digiline = {
 	receptor = {}
 }
 
-local function after_place_node_detector(pos, placer)
-	local placer_pos = placer:get_pos()
-	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",
+	description = S("Node Detector"),
 	mesecons = {receptor = {
 		state = mesecon.state.off
 	}},
 	on_construct = node_detector_make_formspec,
 	on_receive_fields = node_detector_on_receive_fields,
-	sounds = default.node_sound_stone_defaults(),
+	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,
@@ -286,7 +273,7 @@ minetest.register_node("mesecons_detector:node_detector_on", {
 	}},
 	on_construct = node_detector_make_formspec,
 	on_receive_fields = node_detector_on_receive_fields,
-	sounds = default.node_sound_stone_defaults(),
+	sounds = mesecon.node_sound.stone,
 	digiline = node_detector_digiline,
 	on_blast = mesecon.on_blastnode,
 })
@@ -294,18 +281,18 @@ minetest.register_node("mesecons_detector:node_detector_on", {
 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"},
+		{"mesecons_gamecompat:steel_ingot", "group:mesecon_conductor_craftable", "mesecons_gamecompat:steel_ingot"},
+		{"mesecons_gamecompat:steel_ingot", "mesecons_luacontroller:luacontroller0000", "mesecons_gamecompat:steel_ingot"},
+		{"mesecons_gamecompat:steel_ingot", "mesecons_gamecompat:steel_ingot", "mesecons_gamecompat:steel_ingot"},
 	}
 })
 
 minetest.register_craft({
 	output = 'mesecons_detector:node_detector_off',
 	recipe = {
-		{"default:steel_ingot", "group:mesecon_conductor_craftable", "default:steel_ingot"},
-		{"default:steel_ingot", "mesecons_microcontroller:microcontroller0000", "default:steel_ingot"},
-		{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
+		{"mesecons_gamecompat:steel_ingot", "group:mesecon_conductor_craftable", "mesecons_gamecompat:steel_ingot"},
+		{"mesecons_gamecompat:steel_ingot", "mesecons_microcontroller:microcontroller0000", "mesecons_gamecompat:steel_ingot"},
+		{"mesecons_gamecompat:steel_ingot", "mesecons_gamecompat:steel_ingot", "mesecons_gamecompat:steel_ingot"},
 	}
 })
 

mesecons_detector/locale/mesecons_detector.de.tr

@@ -0,0 +1,3 @@
+# textdomain: mesecons_detector
+Player Detector=Spielerdetektor
+Node Detector=Blockdetektor

mesecons_detector/locale/mesecons_detector.eo.tr

@@ -0,0 +1,5 @@
+# textdomain: mesecons_detector
+
+### init.lua ###
+Player Detector=Ludanta Detektilo
+Node Detector=Noda Detektilo

mesecons_detector/locale/template.txt

@@ -0,0 +1,5 @@
+# textdomain: mesecons_detector
+
+### init.lua ###
+Player Detector=
+Node Detector=

mesecons_detector/mod.conf

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

mesecons_doors/init.lua

@@ -1,7 +1,7 @@
 -- 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
+	if minetest.get_node(pos).name ~= check_name then
 		return
 	end
 	local p2 = minetest.get_node(pos).param2
@@ -22,11 +22,11 @@ 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)
+		local function toggle_state1 (pos)
 			on_rightclick(pos, 1, name.."_t_1", name.."_b_2", name.."_t_2", {1,2,3,0})
 		end
 
-		local function toggle_state2 (pos, node)
+		local function toggle_state2 (pos)
 			on_rightclick(pos, 1, name.."_t_2", name.."_b_1", name.."_t_1", {3,0,1,2})
 		end
 
@@ -49,13 +49,13 @@ local function meseconify_door(name)
 		-- new style mesh node based doors
 		local override = {
 			mesecons = {effector = {
-				action_on = function(pos, node)
+				action_on = function(pos)
 					local door = doors.get(pos)
 					if door then
 						door:open()
 					end
 				end,
-				action_off = function(pos, node)
+				action_off = function(pos)
 					local door = doors.get(pos)
 					if door then
 						door:close()
@@ -66,6 +66,10 @@ local function meseconify_door(name)
 		}
 		minetest.override_item(name .. "_a", override)
 		minetest.override_item(name .. "_b", override)
+		if minetest.registered_items[name .. "_c"] then
+			minetest.override_item(name .. "_c", override)
+			minetest.override_item(name .. "_d", override)
+		end
 	end
 end
 
@@ -93,13 +97,13 @@ end
 if doors and doors.get then
 	local override = {
 		mesecons = {effector = {
-			action_on = function(pos, node)
+			action_on = function(pos)
 				local door = doors.get(pos)
 				if door then
 					door:open()
 				end
 			end,
-			action_off = function(pos, node)
+			action_off = function(pos)
 				local door = doors.get(pos)
 				if door then
 					door:close()

mesecons_extrawires/corner.lua

@@ -1,21 +1,14 @@
-local screwdriver_exists = minetest.global_exists("screwdriver")
+local S = minetest.get_translator(minetest.get_current_modname())
 
 local corner_selectionbox = {
 		type = "fixed",
 		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 = "mesh",
@@ -30,10 +23,9 @@ minetest.register_node("mesecons_extrawires:corner_on", {
 	walkable = false,
 	sunlight_propagates = true,
 	selection_box = corner_selectionbox,
-	node_box = corner_nodebox,
 	groups = {dig_immediate = 3, not_in_creative_inventory = 1},
 	drop = "mesecons_extrawires:corner_off",
-	sounds = default.node_sound_defaults(),
+	sounds = mesecon.node_sound.default,
 	mesecons = {conductor =
 	{
 		state = mesecon.state.on,
@@ -41,12 +33,12 @@ minetest.register_node("mesecons_extrawires:corner_on", {
 		offstate = "mesecons_extrawires:corner_off"
 	}},
 	on_blast = mesecon.on_blastnode,
-	on_rotate = screwdriver_exists and screwdriver.rotate_simple,
+	on_rotate = mesecon.on_rotate_horiz,
 })
 
 minetest.register_node("mesecons_extrawires:corner_off", {
 	drawtype = "mesh",
-	description = "Insulated Mesecon Corner",
+	description = S("Insulated Mesecon Corner"),
 	mesh = "mesecons_extrawires_corner.obj",
 	tiles = {
 		{ name = "jeija_insulated_wire_sides_off.png", backface_culling = true },
@@ -58,9 +50,8 @@ minetest.register_node("mesecons_extrawires:corner_off", {
 	walkable = false,
 	sunlight_propagates = true,
 	selection_box = corner_selectionbox,
-	node_box = corner_nodebox,
 	groups = {dig_immediate = 3},
-	sounds = default.node_sound_defaults(),
+	sounds = mesecon.node_sound.default,
 	mesecons = {conductor =
 	{
 		state = mesecon.state.off,
@@ -68,7 +59,7 @@ minetest.register_node("mesecons_extrawires:corner_off", {
 		onstate = "mesecons_extrawires:corner_on"
 	}},
 	on_blast = mesecon.on_blastnode,
-	on_rotate = screwdriver_exists and screwdriver.rotate_simple,
+	on_rotate = mesecon.on_rotate_horiz,
 })
 
 minetest.register_craft({
@@ -78,3 +69,9 @@ minetest.register_craft({
 		{"", "mesecons_insulated:insulated_off"},
 	}
 })
+
+minetest.register_craft({
+	output = "mesecons_insulated:insulated_off",
+	type = "shapeless",
+	recipe = {"mesecons_extrawires:corner_off"}
+})

mesecons_extrawires/crossover.lua

@@ -1,15 +1,15 @@
-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 S = minetest.get_translator(minetest.get_current_modname())
+
+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,7 +19,7 @@ local crossover_states = {
 }
 
 minetest.register_node("mesecons_extrawires:crossover_off", {
-	description = "Insulated Mesecon Crossover",
+	description = S("Insulated Mesecon Crossover"),
 	drawtype = "mesh",
 	mesh = "mesecons_extrawires_crossover.b3d",
 	tiles = {
@@ -34,18 +34,18 @@ minetest.register_node("mesecons_extrawires:crossover_off", {
 	stack_max = 99,
 	selection_box = {type="fixed", fixed={-16/32, -16/32, -16/32, 16/32, -5/32, 16/32}},
 	groups = {dig_immediate=3, mesecon=3},
-	sounds = default.node_sound_defaults(),
+	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!",
+	description = S("You hacker you!"),
 	drop = "mesecons_extrawires:crossover_off",
 	drawtype = "mesh",
 	mesh = "mesecons_extrawires_crossover.b3d",
@@ -61,18 +61,18 @@ minetest.register_node("mesecons_extrawires:crossover_01", {
 	stack_max = 99,
 	selection_box = {type="fixed", fixed={-16/32, -16/32, -16/32, 16/32, -5/32, 16/32}},
 	groups = {dig_immediate=3, mesecon=3, not_in_creative_inventory=1},
-	sounds = default.node_sound_defaults(),
+	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!",
+	description = S("You hacker you!"),
 	drop = "mesecons_extrawires:crossover_off",
 	drawtype = "mesh",
 	mesh = "mesecons_extrawires_crossover.b3d",
@@ -88,18 +88,18 @@ minetest.register_node("mesecons_extrawires:crossover_10", {
 	stack_max = 99,
 	selection_box = {type="fixed", fixed={-16/32, -16/32, -16/32, 16/32, -5/32, 16/32}},
 	groups = {dig_immediate=3, mesecon=3, not_in_creative_inventory=1},
-	sounds = default.node_sound_defaults(),
+	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!",
+	description = S("You hacker you!"),
 	drop = "mesecons_extrawires:crossover_off",
 	drawtype = "mesh",
 	mesh = "mesecons_extrawires_crossover.b3d",
@@ -115,11 +115,11 @@ minetest.register_node("mesecons_extrawires:crossover_on", {
 	stack_max = 99,
 	selection_box = {type="fixed", fixed={-16/32, -16/32, -16/32, 16/32, -5/32, 16/32}},
 	groups = {dig_immediate=3, mesecon=3, not_in_creative_inventory=1},
-	sounds = default.node_sound_defaults(),
+	sounds = mesecon.node_sound.default,
 	mesecons = {
 		conductor = {
 			states = crossover_states,
-			rules = crossover_get_rules(),
+			rules = crossover_rules,
 		}
 	},
 	on_blast = mesecon.on_blastnode,

mesecons_extrawires/doublecorner.lua

@@ -1,12 +1,11 @@
-local rotate
-if minetest.global_exists("screwdriver") then rotate = screwdriver.rotate_simple end
+local S = minetest.get_translator(minetest.get_current_modname())
 
 local doublecorner_selectionbox = {
 	type = "fixed",
 	fixed = { -8/16, -8/16, -8/16, 8/16, -6/16, 8/16 },
 }
 
-local rules = {
+local doublecorner_get_rules = mesecon.horiz_rules_getter({
 	{
 		{ x = 1, y = 0, z = 0 },
 		{ x = 0, y = 0, z = 1 },
@@ -15,19 +14,7 @@ local rules = {
 		{ x = -1, y = 0, z = 0 },
 		{ x = 0, y = 0, z = -1 },
 	},
-}
-
-local doublecorner_rules = {}
-for k = 1, 4 do
-	doublecorner_rules[k] = table.copy(rules)
-	for i, r in ipairs(rules) do
-		rules[i] = mesecon.rotate_rules_left(r)
-	end
-end
-
-local function doublecorner_get_rules(node)
-	return doublecorner_rules[node.param2 % 4 + 1]
-end
+})
 
 local doublecorner_states = {
 	"mesecons_extrawires:doublecorner_00",
@@ -46,7 +33,7 @@ for k, state in ipairs(doublecorner_states) do
 	minetest.register_node(state, {
 		drawtype = "mesh",
 		mesh = "mesecons_extrawires_doublecorner.obj",
-		description = "Insulated Mesecon Double Corner",
+		description = S("Insulated Mesecon Double Corner"),
 		tiles = {
 			{ name = "jeija_insulated_wire_sides_" .. w1 .. ".png", backface_culling = true },
 			{ name = "jeija_insulated_wire_ends_" .. w1 .. ".png", backface_culling = true },
@@ -61,7 +48,7 @@ for k, state in ipairs(doublecorner_states) do
 		selection_box = doublecorner_selectionbox,
 		groups = groups,
 		drop = doublecorner_states[1],
-		sounds = default.node_sound_defaults(),
+		sounds = mesecon.node_sound.default,
 		mesecons = {
 			conductor = {
 				states = doublecorner_states,
@@ -69,7 +56,7 @@ for k, state in ipairs(doublecorner_states) do
 			},
 		},
 		on_blast = mesecon.on_blastnode,
-		on_rotate = rotate,
+		on_rotate = mesecon.on_rotate_horiz,
 	})
 end
 

mesecons_extrawires/locale/mesecons_extrawires.de.tr

@@ -0,0 +1,8 @@
+# textdomain: mesecons_extrawires
+Insulated Mesecon Corner=Isolierte Meseconecke
+Insulated Mesecon Crossover=Isolierter Meseconübergang
+You hacker you!=Sie Hacker!
+Insulated Mesecon Double Corner=Isolierte Mesecondoppelecke
+Mese Wire=Mesedraht
+Insulated Mesecon T-junction=Isolierte Mesecongabelung
+Vertical Mesecon=Vertikaler Mesecon

mesecons_extrawires/locale/mesecons_extrawires.eo.tr

@@ -0,0 +1,20 @@
+# textdomain: mesecons_extrawires
+
+### corner.lua ###
+Insulated Mesecon Corner=Izolita Mesekonduktila Angulo
+
+### crossover.lua ###
+Insulated Mesecon Crossover=Izolita Mesekonduktila Interkruciĝo
+You hacker you!=Vi hakisto
+
+### doublecorner.lua ###
+Insulated Mesecon Double Corner=Izolita Mesekonduktila Duobla Angulo
+
+### mesewire.lua ###
+Mese Wire=Mesea Drato
+
+### tjunction.lua ###
+Insulated Mesecon T-junction=Izolita Mesekonduktila T-Kruciĝo
+
+### vertical.lua ###
+Vertical Mesecon=Vertikala Mesekonduktilo

mesecons_extrawires/locale/template.txt

@@ -0,0 +1,20 @@
+# textdomain: mesecons_extrawires
+
+### corner.lua ###
+Insulated Mesecon Corner=
+
+### crossover.lua ###
+Insulated Mesecon Crossover=
+You hacker you!=
+
+### doublecorner.lua ###
+Insulated Mesecon Double Corner=
+
+### mesewire.lua ###
+Mese Wire=
+
+### tjunction.lua ###
+Insulated Mesecon T-junction=
+
+### vertical.lua ###
+Vertical Mesecon=

mesecons_extrawires/mesewire.lua

@@ -1,3 +1,22 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
+local mese_nodename = minetest.registered_aliases["mesecons_gamecompat:mese"]
+if mese_nodename then
+	-- Convert placeholders.
+	minetest.register_alias("mesecons_extrawires:mese", mese_nodename)
+else
+	-- Register placeholder.
+	mese_nodename = "mesecons_extrawires:mese"
+	minetest.register_node("mesecons_extrawires:mese", {
+		description = S("Mese Wire"),
+		tiles = {"mesecons_wire_off.png"},
+		paramtype = "light",
+		light_source = 3,
+		groups = {cracky = 1},
+		sounds = mesecon.node_sound.stone,
+	})
+end
+
 local mesewire_rules =
 {
 	{x = 1, y = 0, z = 0},
@@ -8,7 +27,7 @@ local mesewire_rules =
 	{x = 0, y = 0, z =-1},
 }
 
-minetest.override_item("default:mese", {
+minetest.override_item(mese_nodename, {
 	mesecons = {conductor = {
 		state = mesecon.state.off,
 		onstate = "mesecons_extrawires:mese_powered",
@@ -18,15 +37,17 @@ minetest.override_item("default:mese", {
 
 -- Copy node definition of powered mese from normal mese
 -- and brighten texture tiles to indicate mese is powered
-local powered_def = mesecon.mergetable(minetest.registered_nodes["default:mese"], {
-	drop = "default:mese",
-	light_source = 5,
+local unpowered_def = minetest.registered_nodes[mese_nodename]
+local powered_def = mesecon.merge_tables(unpowered_def, {
+	drop = mese_nodename,
+	paramtype = "light",
+	light_source = math.min(unpowered_def.light_source + 2, minetest.LIGHT_MAX),
 	mesecons = {conductor = {
 		state = mesecon.state.on,
-		offstate = "default:mese",
+		offstate = mese_nodename,
 		rules = mesewire_rules
 	}},
-	groups = {cracky = 1, not_in_creative_inventory = 1},
+	groups = mesecon.merge_tables(unpowered_def.groups or {}, {not_in_creative_inventory = 1}),
 	on_blast = mesecon.on_blastnode,
 })
 

mesecons_extrawires/mod.conf

@@ -1,3 +1,2 @@
 name = mesecons_extrawires
-depends = default, mesecons
-optional_depends = screwdriver
+depends = mesecons, mesecons_gamecompat

mesecons_extrawires/tjunction.lua

@@ -1,4 +1,4 @@
-local screwdriver_exists = minetest.global_exists("screwdriver")
+local S = minetest.get_translator(minetest.get_current_modname())
 
 local tjunction_nodebox = {
 	type = "fixed",
@@ -12,18 +12,11 @@ local tjunction_selectionbox = {
 		fixed = { -16/32, -16/32, -16/32, 16/32, -12/32, 7/32 },
 }
 
-local tjunction_get_rules = function (node)
-	local rules =
-	{{x = 0,  y = 0,  z =  1},
-	 {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 tjunction_get_rules = mesecon.horiz_rules_getter({
+	{x = 1, y = 0, z = 0},
+	{x = 0, y = 0, z = -1},
+	{x = -1, y = 0, z = 0},
+})
 
 minetest.register_node("mesecons_extrawires:tjunction_on", {
 	drawtype = "nodebox",
@@ -44,7 +37,7 @@ minetest.register_node("mesecons_extrawires:tjunction_on", {
 	node_box = tjunction_nodebox,
 	groups = {dig_immediate = 3, not_in_creative_inventory = 1},
 	drop = "mesecons_extrawires:tjunction_off",
-	sounds = default.node_sound_defaults(),
+	sounds = mesecon.node_sound.default,
 	mesecons = {conductor =
 	{
 		state = mesecon.state.on,
@@ -52,12 +45,12 @@ minetest.register_node("mesecons_extrawires:tjunction_on", {
 		offstate = "mesecons_extrawires:tjunction_off"
 	}},
 	on_blast = mesecon.on_blastnode,
-	on_rotate = screwdriver_exists and screwdriver.rotate_simple,
+	on_rotate = mesecon.on_rotate_horiz,
 })
 
 minetest.register_node("mesecons_extrawires:tjunction_off", {
 	drawtype = "nodebox",
-	description = "Insulated Mesecon T-junction",
+	description = S("Insulated Mesecon T-junction"),
 	tiles = {
 		"jeija_insulated_wire_tjunction_tb_off.png",
 		"jeija_insulated_wire_tjunction_tb_off.png^[transformR180",
@@ -74,7 +67,7 @@ minetest.register_node("mesecons_extrawires:tjunction_off", {
 	selection_box = tjunction_selectionbox,
 	node_box = tjunction_nodebox,
 	groups = {dig_immediate = 3},
-	sounds = default.node_sound_defaults(),
+	sounds = mesecon.node_sound.default,
 	mesecons = {conductor =
 	{
 		state = mesecon.state.off,
@@ -82,7 +75,7 @@ minetest.register_node("mesecons_extrawires:tjunction_off", {
 		onstate = "mesecons_extrawires:tjunction_on"
 	}},
 	on_blast = mesecon.on_blastnode,
-	on_rotate = screwdriver_exists and screwdriver.rotate_simple,
+	on_rotate = mesecon.on_rotate_horiz,
 })
 
 minetest.register_craft({

mesecons_extrawires/vertical.lua

@@ -1,3 +1,5 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
 local vertical_box = {
 	type = "fixed",
 	fixed = {-1/16, -8/16, -1/16, 1/16, 8/16, 1/16}
@@ -69,7 +71,7 @@ local vertical_updatepos = function (pos)
 	end
 end
 
-local vertical_update = function (pos, node)
+local vertical_update = function (pos)
 	vertical_updatepos(pos) -- this one
 	vertical_updatepos(vector.add(pos, vertical_rules[1])) -- above
 	vertical_updatepos(vector.add(pos, vertical_rules[2])) -- below
@@ -77,7 +79,7 @@ end
 
 -- Vertical wire
 mesecon.register_node("mesecons_extrawires:vertical", {
-	description = "Vertical Mesecon",
+	description = S("Vertical Mesecon"),
 	drawtype = "nodebox",
 	walkable = false,
 	paramtype = "light",
@@ -89,7 +91,7 @@ mesecon.register_node("mesecons_extrawires:vertical", {
 	drop = "mesecons_extrawires:vertical_off",
 	after_place_node = vertical_update,
 	after_dig_node = vertical_update,
-	sounds = default.node_sound_defaults(),
+	sounds = mesecon.node_sound.default,
 },{
 	tiles = {"mesecons_wire_off.png"},
 	groups = {dig_immediate=3},
@@ -110,7 +112,7 @@ mesecon.register_node("mesecons_extrawires:vertical", {
 
 -- Vertical wire top
 mesecon.register_node("mesecons_extrawires:vertical_top", {
-	description = "Vertical mesecon",
+	description = S("Vertical Mesecon"),
 	drawtype = "nodebox",
 	walkable = false,
 	paramtype = "light",
@@ -123,7 +125,7 @@ mesecon.register_node("mesecons_extrawires:vertical_top", {
 	drop = "mesecons_extrawires:vertical_off",
 	after_place_node = vertical_update,
 	after_dig_node = vertical_update,
-	sounds = default.node_sound_defaults(),
+	sounds = mesecon.node_sound.default,
 },{
 	tiles = {"mesecons_wire_off.png"},
 	mesecons = {conductor = {
@@ -142,7 +144,7 @@ mesecon.register_node("mesecons_extrawires:vertical_top", {
 
 -- Vertical wire bottom
 mesecon.register_node("mesecons_extrawires:vertical_bottom", {
-	description = "Vertical mesecon",
+	description = S("Vertical Mesecon"),
 	drawtype = "nodebox",
 	walkable = false,
 	paramtype = "light",
@@ -155,7 +157,7 @@ mesecon.register_node("mesecons_extrawires:vertical_bottom", {
 	drop = "mesecons_extrawires:vertical_off",
 	after_place_node = vertical_update,
 	after_dig_node = vertical_update,
-	sounds = default.node_sound_defaults(),
+	sounds = mesecon.node_sound.default,
 },{
 	tiles = {"mesecons_wire_off.png"},
 	mesecons = {conductor = {
@@ -175,9 +177,9 @@ mesecon.register_node("mesecons_extrawires:vertical_bottom", {
 minetest.register_craft({
 	output = "mesecons_extrawires:vertical_off 3",
 	recipe = {
-		{"mesecons:wire_00000000_off"},
-		{"mesecons:wire_00000000_off"},
-		{"mesecons:wire_00000000_off"}
+		{"group:mesecon_conductor_craftable"},
+		{"group:mesecon_conductor_craftable"},
+		{"group:mesecon_conductor_craftable"},
 	}
 })
 

mesecons_fpga/init.lua

@@ -1,3 +1,5 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
 local plg = {}
 plg.rules = {}
 -- per-player formspec positions
@@ -59,7 +61,7 @@ plg.register_nodes = function(template)
 end
 
 plg.register_nodes({
-	description = "FPGA",
+	description = S("FPGA"),
 	drawtype = "nodebox",
 	tiles = {
 		"", -- replaced later
@@ -96,7 +98,7 @@ plg.register_nodes({
 		meta:set_int("valid", 0)
 		meta:set_string("infotext", "FPGA")
 	end,
-	on_rightclick = function(pos, node, clicker)
+	on_rightclick = function(pos, _, clicker)
 		if not minetest.is_player(clicker) then
 			return
 		end
@@ -109,13 +111,14 @@ plg.register_nodes({
 		local is = lcore.deserialize(meta:get_string("instr"))
 		minetest.show_formspec(name, "mesecons:fpga", plg.to_formspec_string(is, nil))
 	end,
-	sounds = default.node_sound_stone_defaults(),
+	sounds = mesecon.node_sound.stone,
 	mesecons = {
 		effector = {
 			rules = {}, -- replaced later
-			action_change = function(pos, node, rule, newstate)
-				plg.ports_changed(pos, rule, newstate)
-				plg.update(pos)
+			action_change = function(pos, _, rule, newstate)
+				if plg.ports_changed(pos, rule, newstate) then
+					plg.update(pos)
+				end
 			end
 		}
 	},
@@ -129,7 +132,7 @@ plg.register_nodes({
 		end
 	end,
 	on_blast = mesecon.on_blastnode,
-	on_rotate = function(pos, node, user, mode)
+	on_rotate = function(pos, _, user, mode)
 		local abcd1 = {"A", "B", "C", "D"}
 		local abcd2 = {A = 1, B = 2, C = 3, D = 4}
 		local ops = {"op1", "op2", "dst"}
@@ -326,8 +329,10 @@ plg.update = function(pos)
 	plg.setports(pos, A, B, C, D)
 end
 
+-- Updates the port states according to the signal change.
+-- Returns whether the port states actually changed.
 plg.ports_changed = function(pos, rule, newstate)
-	if rule == nil then return end
+	if rule == nil then return false end
 	local meta = minetest.get_meta(pos)
 	local states
 
@@ -347,10 +352,14 @@ plg.ports_changed = function(pos, rule, newstate)
 	local portno = ({4, 1, nil, 3, 2})[3 + rule.x + 2*rule.z]
 	states[portno] = (newstate == "on")
 
-	meta:set_string("portstates",
+	local new_portstates =
 			(states[1] and "1" or "0") .. (states[2] and "1" or "0") ..
 			(states[3] and "1" or "0") .. (states[4] and "1" or "0")
-	)
+	if new_portstates ~= s then
+		meta:set_string("portstates", new_portstates)
+		return true
+	end
+	return false
 end
 
 plg.getports = function(pos) -- gets merged states of INPUT & OUTPUT

mesecons_fpga/locale/mesecons_fpga.de.tr

@@ -0,0 +1,3 @@
+# textdomain: mesecons_fpga
+FPGA=FPGA
+FPGA Programmer=FPGA-Programmierer

mesecons_fpga/locale/mesecons_fpga.eo.tr

@@ -0,0 +1,7 @@
+# textdomain: mesecons_fpga
+
+### init.lua ###
+FPGA=FPGA
+
+### tool.lua ###
+FPGA Programmer=FPGA Programilo

mesecons_fpga/locale/template.txt

@@ -0,0 +1,7 @@
+# textdomain: mesecons_fpga
+
+### init.lua ###
+FPGA=
+
+### tool.lua ###
+FPGA Programmer=

mesecons_fpga/logic.lua

@@ -10,10 +10,10 @@ local operations = {
 	-- unary:   Whether this gate only has one input
 	{ gate = "and",  short = "&", fs_name = " AND", func = function(a, b) return a and b end },
 	{ gate = "or",   short = "|", fs_name = "  OR", func = function(a, b) return a or b end },
-	{ gate = "not",  short = "~", fs_name = " NOT", func = function(a, b) return not b end, unary = true },
+	{ gate = "not",  short = "~", fs_name = " NOT", func = function(_, b) return not b end, unary = true },
 	{ gate = "xor",  short = "^", fs_name = " XOR", func = function(a, b) return a ~= b end },
 	{ gate = "nand", short = "?", fs_name = "NAND", func = function(a, b) return not (a and b) end },
-	{ gate = "buf",  short = "_", fs_name = "   =", func = function(a, b) return b end, unary = true },
+	{ gate = "buf",  short = "_", fs_name = "   =", func = function(_, b) return b end, unary = true },
 	{ gate = "xnor", short = "=", fs_name = "XNOR", func = function(a, b) return a == b end },
 	{ gate = "nor",  short = "!", fs_name = " NOR", func = function(a, b) return not (a or b) end },
 }

mesecons_fpga/mod.conf

@@ -1,3 +1,3 @@
 name = mesecons_fpga
-depends = mesecons
+depends = mesecons, mesecons_gamecompat
 optional_depends = screwdriver

mesecons_fpga/spec/helper_spec.lua

@@ -0,0 +1,106 @@
+require("mineunit")
+
+fixture("mesecons_fpga")
+fixture("screwdriver")
+
+local pos = {x = 0, y = 0, z = 0}
+local pos_a = {x = -1, y = 0, z =  0}
+local pos_b = {x =  0, y = 0, z =  1}
+local pos_c = {x =  1, y = 0, z =  0}
+local pos_d = {x =  0, y = 0, z = -1}
+
+describe("FPGA rotation", function()
+	before_each(function()
+		world.set_node(pos, "mesecons_fpga:fpga0000")
+	end)
+
+	after_each(function()
+		mesecon._test_reset()
+		world.clear()
+	end)
+
+	it("rotates I/O operands clockwise", function()
+		mesecon._test_program_fpga(pos, {{"A", "OR", "B", "C"}})
+
+		local node = world.get_node(pos)
+		minetest.registered_nodes[node.name].on_rotate(pos, node, nil, screwdriver.ROTATE_FACE)
+
+		mesecon._test_place(pos_b, "mesecons:test_receptor_on")
+		mineunit:execute_globalstep() -- Execute receptor_on action
+		mineunit:execute_globalstep() -- Execute activate/change actions
+		assert.equal("mesecons_fpga:fpga1000", world.get_node(pos).name)
+
+		mesecon._test_dig(pos_b)
+		mesecon._test_place(pos_c, "mesecons:test_receptor_on")
+		mineunit:execute_globalstep() -- Execute receptor_on/receptor_off actions
+		mineunit:execute_globalstep() -- Execute activate/deactivate/change actions
+		assert.equal("mesecons_fpga:fpga1000", world.get_node(pos).name)
+	end)
+
+	it("rotates I/O operands counterclockwise", function()
+		mesecon._test_program_fpga(pos, {{"A", "OR", "B", "C"}})
+
+		local node = world.get_node(pos)
+		minetest.registered_nodes[node.name].on_rotate(pos, node, nil, screwdriver.ROTATE_AXIS)
+
+		mesecon._test_place(pos_d, "mesecons:test_receptor_on")
+		mineunit:execute_globalstep() -- Execute receptor_on action
+		mineunit:execute_globalstep() -- Execute activate/change actions
+		assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
+
+		mesecon._test_dig(pos_d)
+		mesecon._test_place(pos_a, "mesecons:test_receptor_on")
+		mineunit:execute_globalstep() -- Execute receptor_on/receptor_off actions
+		mineunit:execute_globalstep() -- Execute activate/deactivate/change actions
+		assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
+	end)
+
+	it("updates ports", function()
+		mesecon._test_program_fpga(pos, {{"NOT", "A", "B"}})
+		assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
+
+		local node = world.get_node(pos)
+		minetest.registered_nodes[node.name].on_rotate(pos, node, nil, screwdriver.ROTATE_AXIS)
+		assert.equal("mesecons_fpga:fpga0001", world.get_node(pos).name)
+	end)
+end)
+
+describe("FPGA programmer", function()
+	local pos2 = {x = 10, y = 0, z = 0}
+
+	before_each(function()
+		world.set_node(pos, "mesecons_fpga:fpga0000")
+		world.set_node(pos2, "mesecons_fpga:fpga0000")
+	end)
+
+	after_each(function()
+		mesecon._test_reset()
+		world.clear()
+	end)
+
+	it("transfers instructions", function()
+		mesecon._test_program_fpga(pos2, {{"NOT", "A", "B"}})
+		mesecon._test_paste_fpga_program(pos, mesecon._test_copy_fpga_program(pos2))
+		assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
+	end)
+
+	it("does not copy from new FPGAs", function()
+		mesecon._test_program_fpga(pos, {{"NOT", "A", "B"}})
+		mesecon._test_paste_fpga_program(pos, mesecon._test_copy_fpga_program(pos2))
+		assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
+	end)
+
+	it("does not copy from cleared FPGAs", function()
+		mesecon._test_program_fpga(pos, {{"NOT", "A", "B"}})
+		mesecon._test_program_fpga(pos2, {{"=", "A", "B"}})
+		mesecon._test_program_fpga(pos2, {})
+		mesecon._test_paste_fpga_program(pos, mesecon._test_copy_fpga_program(pos2))
+		assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
+	end)
+
+	it("does not copy from non-FPGA nodes", function()
+		mesecon._test_program_fpga(pos, {{"NOT", "A", "B"}})
+		mesecon._test_paste_fpga_program(pos, mesecon._test_copy_fpga_program(vector.add(pos2, 1)))
+		assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
+	end)
+end)

mesecons_fpga/spec/logic_spec.lua

@@ -0,0 +1,235 @@
+require("mineunit")
+
+fixture("mesecons_fpga")
+
+describe("FPGA logic", function()
+	local pos = {x = 0, y = 0, z = 0}
+	local pos_a = {x = -1, y = 0, z =  0}
+	local pos_b = {x =  0, y = 0, z =  1}
+	local pos_c = {x =  1, y = 0, z =  0}
+	local pos_d = {x =  0, y = 0, z = -1}
+
+	local fpga_set = false
+
+	local function set_fpga()
+		if not fpga_set then
+			world.set_node(pos, "mesecons_fpga:fpga0000")
+			fpga_set = true
+		end
+	end
+	before_each(set_fpga)
+
+	local function reset_world()
+		if fpga_set then
+			mesecon._test_reset()
+			world.clear()
+			fpga_set = false
+		end
+	end
+	after_each(reset_world)
+
+	local function test_program(inputs, outputs, program)
+		set_fpga()
+
+		mesecon._test_program_fpga(pos, program)
+
+		if inputs.a then mesecon._test_place(pos_a, "mesecons:test_receptor_on") end
+		if inputs.b then mesecon._test_place(pos_b, "mesecons:test_receptor_on") end
+		if inputs.c then mesecon._test_place(pos_c, "mesecons:test_receptor_on") end
+		if inputs.d then mesecon._test_place(pos_d, "mesecons:test_receptor_on") end
+		mineunit:execute_globalstep() -- Execute receptor_on actions
+		mineunit:execute_globalstep() -- Execute activate/change actions
+
+		local expected_name = "mesecons_fpga:fpga"
+				.. (outputs.d and 1 or 0) .. (outputs.c and 1 or 0)
+				.. (outputs.b and 1 or 0) .. (outputs.a and 1 or 0)
+		assert.equal(expected_name, world.get_node(pos).name)
+
+		reset_world()
+	end
+
+	it("operator and", function()
+		local prog = {{"A", "AND", "B", "C"}}
+		test_program({}, {}, prog)
+		test_program({a = true}, {}, prog)
+		test_program({b = true}, {}, prog)
+		test_program({a = true, b = true}, {c = true}, prog)
+	end)
+
+	it("operator or", function()
+		local prog = {{"A", "OR", "B", "C"}}
+		test_program({}, {}, prog)
+		test_program({a = true}, {c = true}, prog)
+		test_program({b = true}, {c = true}, prog)
+		test_program({a = true, b = true}, {c = true}, prog)
+	end)
+
+	it("operator not", function()
+		local prog = {{"NOT", "A", "B"}}
+		test_program({}, {b = true}, prog)
+		test_program({a = true}, {}, prog)
+	end)
+
+	it("operator xor", function()
+		local prog = {{"A", "XOR", "B", "C"}}
+		test_program({}, {}, prog)
+		test_program({a = true}, {c = true}, prog)
+		test_program({b = true}, {c = true}, prog)
+		test_program({a = true, b = true}, {}, prog)
+	end)
+
+	it("operator nand", function()
+		local prog = {{"A", "NAND", "B", "C"}}
+		test_program({}, {c = true}, prog)
+		test_program({a = true}, {c = true}, prog)
+		test_program({b = true}, {c = true}, prog)
+		test_program({a = true, b = true}, {}, prog)
+	end)
+
+	it("operator buf", function()
+		local prog = {{"=", "A", "B"}}
+		test_program({}, {}, prog)
+		test_program({a = true}, {b = true}, prog)
+	end)
+
+	it("operator xnor", function()
+		local prog = {{"A", "XNOR", "B", "C"}}
+		test_program({}, {c = true}, prog)
+		test_program({a = true}, {}, prog)
+		test_program({b = true}, {}, prog)
+		test_program({a = true, b = true}, {c = true}, prog)
+	end)
+
+	it("operator nor", function()
+		local prog = {{"A", "NOR", "B", "C"}}
+		test_program({}, {c = true}, prog)
+		test_program({a = true}, {}, prog)
+		test_program({b = true}, {}, prog)
+		test_program({a = true, b = true}, {}, prog)
+	end)
+
+	it("rejects duplicate operands", function()
+		test_program({a = true}, {}, {{"A", "OR", "A", "B"}})
+		test_program({a = true}, {}, {{"=", "A", "0"}, {"0", "OR", "0", "B"}})
+	end)
+
+	it("rejects unassigned memory operands", function()
+		test_program({a = true}, {}, {{"A", "OR", "0", "B"}})
+		test_program({a = true}, {}, {{"0", "OR", "A", "B"}})
+	end)
+
+	it("rejects double memory assignment", function()
+		test_program({a = true}, {}, {{"=", "A", "0"}, {"=", "A", "0"}, {"=", "0", "B"}})
+	end)
+
+	it("rejects assignment to memory operand", function()
+		test_program({a = true}, {}, {{"=", "A", "0"}, {"A", "OR", "0", "0"}, {"=", "0", "B"}})
+	end)
+
+	it("allows double port assignment", function()
+		test_program({a = true}, {b = true}, {{"NOT", "A", "B"}, {"=", "A", "B"}})
+	end)
+
+	it("allows assignment to port operand", function()
+		test_program({a = true}, {b = true}, {{"A", "OR", "B", "B"}})
+	end)
+
+	it("preserves initial pin states", function()
+		test_program({a = true}, {b = true}, {{"=", "A", "B"}, {"=", "B", "C"}})
+	end)
+
+	it("rejects binary operations with single operands", function()
+		test_program({a = true}, {}, {{"=", "A", "B"}, {" ", "OR", "A", "C"}})
+		test_program({a = true}, {}, {{"=", "A", "B"}, {"A", "OR", " ", "C"}})
+	end)
+
+	it("rejects unary operations with first operands", function()
+		test_program({a = true}, {}, {{"=", "A", "B"}, {"A", "=", " ", "C"}})
+	end)
+
+	it("rejects operations without destinations", function()
+		test_program({a = true}, {}, {{"=", "A", "B"}, {"=", "A", " "}})
+	end)
+
+	it("allows blank statements", function()
+		test_program({a = true}, {b = true, c = true}, {
+			{" ", " ", " ", " "},
+			{"=", "A", "B"},
+			{" ", " ", " ", " "},
+			{" ", " ", " ", " "},
+			{"=", "A", "C"},
+		})
+	end)
+
+	it("transmits output signals to adjacent nodes", function()
+		mesecon._test_program_fpga(pos, {
+			{"=", "A", "B"},
+			{"=", "A", "C"},
+			{"NOT", "A", "D"},
+		})
+		mesecon._test_place(pos_b, "mesecons:test_effector")
+		mesecon._test_place(pos_c, "mesecons:test_effector")
+		mesecon._test_place(pos_d, "mesecons:test_effector")
+		mineunit:execute_globalstep() -- Execute receptor_on actions
+		mineunit:execute_globalstep() -- Execute activate/change actions
+
+		-- Makes an object from the last three effector events in the list for use with assert.same.
+		-- This is necessary to ignore the ordering of events.
+		local function event_tester(list)
+			local o = {list[#list - 2], list[#list - 1], list[#list - 0]}
+			table.sort(o, function(a, b)
+				local fmt = "%s %d %d %d"
+				return fmt:format(a[1], a[2].x, a[2].y, a[2].z) < fmt:format(b[1], b[2].x, b[2].y, b[2].z)
+			end)
+			return o
+		end
+
+		mesecon._test_place(pos_a, "mesecons:test_receptor_on")
+		mineunit:execute_globalstep() -- Execute receptor_on action
+		mineunit:execute_globalstep() -- Execute activate/change actions
+		mineunit:execute_globalstep() -- Execute receptor_on/receptor_off actions
+		mineunit:execute_globalstep() -- Execute activate/deactivate/change actions
+		assert.equal("mesecons_fpga:fpga0110", world.get_node(pos).name)
+		assert.same(event_tester({{"on", pos_b}, {"on", pos_c}, {"off", pos_d}}), event_tester(mesecon._test_effector_events))
+
+		mesecon._test_dig(pos_a)
+		mineunit:execute_globalstep() -- Execute receptor_off action
+		mineunit:execute_globalstep() -- Execute deactivate/change actions
+		mineunit:execute_globalstep() -- Execute receptor_on/receptor_off actions
+		mineunit:execute_globalstep() -- Execute activate/deactivate/change actions
+		assert.equal("mesecons_fpga:fpga1000", world.get_node(pos).name)
+		assert.same(event_tester({{"off", pos_b}, {"off", pos_c}, {"on", pos_d}}), event_tester(mesecon._test_effector_events))
+	end)
+
+	it("considers past outputs in determining inputs", function()
+		-- Memory cell: Turning on A turns on C; turning on B turns off C.
+		mesecon._test_program_fpga(pos, {
+			{"A", "OR", "C", "0"},
+			{"B", "OR", "D", "1"},
+			{"NOT", "A", "2"},
+			{"NOT", "B", "3"},
+			{"0", "AND", "3", "C"},
+			{"1", "AND", "2", "D"},
+		})
+
+		mesecon._test_place(pos_a, "mesecons:test_receptor_on")
+		mineunit:execute_globalstep() -- Execute receptor_on actions
+		mineunit:execute_globalstep() -- Execute activate/change actions
+		assert.equal("mesecons_fpga:fpga0100", world.get_node(pos).name)
+
+		mesecon._test_dig(pos_a)
+		mineunit:execute_globalstep() -- Execute receptor_off actions
+		mineunit:execute_globalstep() -- Execute deactivate/change actions
+		assert.equal("mesecons_fpga:fpga0100", world.get_node(pos).name)
+
+		mesecon._test_place(pos_b, "mesecons:test_receptor_on")
+		mineunit:execute_globalstep() -- Execute receptor_on actions
+		mineunit:execute_globalstep() -- Execute activate/change actions
+		assert.equal("mesecons_fpga:fpga1000", world.get_node(pos).name)
+
+		mesecon._test_dig(pos_b)
+		mineunit:execute_globalstep() -- Execute receptor_off actions
+		mineunit:execute_globalstep() -- Execute deactivate/change actions
+		assert.equal("mesecons_fpga:fpga1000", world.get_node(pos).name)
+	end)
+end)

mesecons_fpga/spec/mineunit.conf

@@ -0,0 +1 @@
+fixture_paths = {"../.test_fixtures"}

mesecons_fpga/tool.lua

@@ -1,8 +1,10 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
 return function(plg)
 
 
 minetest.register_tool("mesecons_fpga:programmer", {
-	description = "FPGA Programmer",
+	description = S("FPGA Programmer"),
 	inventory_image = "jeija_fpga_programmer.png",
 	stack_max = 1,
 	on_place = function(itemstack, placer, pointed_thing)
@@ -21,7 +23,7 @@ minetest.register_tool("mesecons_fpga:programmer", {
 			minetest.sound_play("mesecons_fpga_fail", { pos = placer:get_pos(), gain = 0.1, max_hear_distance = 4 }, true)
 			return itemstack
 		end
-		itemstack:set_metadata(meta:get_string("instr"))
+		itemstack:get_meta():set_string("", meta:get_string("instr"))
 		minetest.chat_send_player(placer:get_player_name(), "FPGA gate configuration was successfully copied!")
 		minetest.sound_play("mesecons_fpga_copy", { pos = placer:get_pos(), gain = 0.1, max_hear_distance = 4 }, true)
 
@@ -42,7 +44,7 @@ minetest.register_tool("mesecons_fpga:programmer", {
 			return itemstack
 		end
 
-		local imeta = itemstack:get_metadata()
+		local imeta = itemstack:get_meta():get_string("")
 		if imeta == "" then
 			minetest.chat_send_player(player_name, "Use shift+right-click to copy a gate configuration first.")
 			minetest.sound_play("mesecons_fpga_fail", { pos = user:get_pos(), gain = 0.1, max_hear_distance = 4 }, true)

mesecons_gamecompat/compat_mtg.lua

@@ -0,0 +1,71 @@
+--Aliases
+
+minetest.register_alias("mesecons_gamecompat:chest", "default:chest")
+minetest.register_alias("mesecons_gamecompat:chest_locked", "default:chest_locked")
+minetest.register_alias("mesecons_gamecompat:coalblock", "default:coalblock")
+minetest.register_alias("mesecons_gamecompat:cobble", "default:cobble")
+minetest.register_alias("mesecons_gamecompat:glass", "default:glass")
+minetest.register_alias("mesecons_gamecompat:lava_source", "default:lava_source")
+minetest.register_alias("mesecons_gamecompat:mese", "default:mese")
+minetest.register_alias("mesecons_gamecompat:mese_crystal", "default:mese_crystal")
+minetest.register_alias("mesecons_gamecompat:mese_crystal_fragment", "default:mese_crystal_fragment")
+minetest.register_alias("mesecons_gamecompat:obsidian_glass", "default:obsidian_glass")
+minetest.register_alias("mesecons_gamecompat:stone", "default:stone")
+minetest.register_alias("mesecons_gamecompat:steel_ingot", "default:steel_ingot")
+minetest.register_alias("mesecons_gamecompat:steelblock", "default:steelblock")
+minetest.register_alias("mesecons_gamecompat:torch", "default:torch")
+
+if minetest.get_modpath("dye") then
+	for _, color in ipairs(mesecon.dye_colors) do
+		minetest.register_alias("mesecons_gamecompat:dye_" .. color, "dye:" .. color)
+	end
+end
+
+-- Sounds
+
+mesecon.node_sound.default = default.node_sound_defaults()
+mesecon.node_sound.glass = default.node_sound_glass_defaults()
+mesecon.node_sound.leaves = default.node_sound_leaves_defaults()
+mesecon.node_sound.stone = default.node_sound_stone_defaults()
+mesecon.node_sound.wood = default.node_sound_wood_defaults()
+
+if minetest.get_modpath("fire") then
+	mesecon.sound_name.fire = "fire_fire"
+end
+
+if minetest.get_modpath("tnt") then
+	mesecon.sound_name.explode = "tnt_explode"
+end
+
+-- Textures
+
+mesecon.texture.steel_block = "default_steel_block.png"
+
+-- MVPS stoppers
+
+if minetest.get_modpath("mesecons_mvps") then
+	-- All of the locked and internal nodes in Minetest Game
+	for _, name in ipairs({
+		"default:chest_locked",
+		"default:chest_locked_open",
+		"doors:door_steel_b_1", -- old style doors
+		"doors:door_steel_b_2", --
+		"doors:door_steel_t_1", --
+		"doors:door_steel_t_2", --
+		"doors:door_steel_a",   -- new style doors
+		"doors:door_steel_b",   --
+		"doors:door_steel_c",   --
+		"doors:door_steel_d",   --
+		"doors:hidden",
+		"doors:trapdoor_steel",
+		"doors:trapdoor_steel_open",
+		"xpanes:door_steel_bar_a",
+		"xpanes:door_steel_bar_b",
+		"xpanes:door_steel_bar_c",
+		"xpanes:door_steel_bar_d",
+		"xpanes:trapdoor_steel_bar",
+		"xpanes:trapdoor_steel_bar_open",
+	}) do
+		mesecon.register_mvps_stopper(name)
+	end
+end

mesecons_gamecompat/init.lua

@@ -0,0 +1,15 @@
+mesecon.node_sound = {}
+
+mesecon.sound_name = {}
+
+mesecon.texture = {}
+
+mesecon.dye_colors = {
+	"red", "green", "blue", "grey", "dark_grey", "yellow",
+	"orange", "white", "pink", "magenta", "cyan", "violet",
+}
+
+if minetest.get_modpath("default") then
+	minetest.log("info", "Mesecons: detected Minetest Game for game compatibility")
+	dofile(minetest.get_modpath("mesecons_gamecompat").."/compat_mtg.lua")
+end

mesecons_gamecompat/mod.conf

@@ -0,0 +1,3 @@
+name = mesecons_gamecompat
+depends = mesecons
+optional_depends = fire, default, dye, mesecons_mvps, tnt

mesecons_gates/init.lua

@@ -11,39 +11,30 @@ local nodebox = {
 	},
 }
 
-local function gate_rotate_rules(node, rules)
-	for rotations = 0, node.param2 - 1 do
-		rules = mesecon.rotate_rules_left(rules)
-	end
-	return rules
-end
+local gate_get_output_rules = mesecon.horiz_rules_getter({{x = 1, y = 0, z = 0}})
 
-local function gate_get_output_rules(node)
-	return gate_rotate_rules(node, {{x=1, y=0, z=0}})
-end
+local gate_get_input_rules_oneinput = mesecon.horiz_rules_getter({{x =-1, y = 0, z = 0}})
 
-local function gate_get_input_rules_oneinput(node)
-	return gate_rotate_rules(node, {{x=-1, y=0, z=0}})
-end
-
-local function gate_get_input_rules_twoinputs(node)
-	return gate_rotate_rules(node, {{x=0, y=0, z=1, name="input1"},
-		{x=0, y=0, z=-1, name="input2"}})
-end
+local gate_get_input_rules_twoinputs = mesecon.horiz_rules_getter({
+	{x = 0, y = 0, z = 1, name = "input1"},
+	{x = 0, y = 0, z = -1, name = "input2"},
+})
 
 local function set_gate(pos, node, state)
 	local gate = minetest.registered_nodes[node.name]
 
-	if mesecon.do_overheat(pos) then
-		minetest.remove_node(pos)
-		mesecon.receptor_off(pos, gate_get_output_rules(node))
-		minetest.add_item(pos, gate.drop)
-	elseif state then
-		minetest.swap_node(pos, {name = gate.onstate, param2=node.param2})
-		mesecon.receptor_on(pos, gate_get_output_rules(node))
-	else
-		minetest.swap_node(pos, {name = gate.offstate, param2=node.param2})
-		mesecon.receptor_off(pos, gate_get_output_rules(node))
+	local new_nodename = state and gate.onstate or gate.offstate
+	minetest.swap_node(pos, {name = new_nodename, param2 = node.param2})
+	if new_nodename ~= node.name then
+		if mesecon.do_overheat(pos) then
+			minetest.remove_node(pos)
+			mesecon.receptor_off(pos, gate_get_output_rules(node))
+			minetest.add_item(pos, gate.drop)
+		elseif state then
+			mesecon.receptor_on(pos, gate_get_output_rules(node))
+		else
+			mesecon.receptor_off(pos, gate_get_output_rules(node))
+		end
 	end
 end
 
@@ -53,11 +44,36 @@ local function update_gate(pos, node, link, newstate)
 	if gate.inputnumber == 1 then
 		set_gate(pos, node, gate.assess(newstate == "on"))
 	elseif gate.inputnumber == 2 then
-		local meta = minetest.get_meta(pos)
-		meta:set_int(link.name, newstate == "on" and 1 or 0)
-
-		local val1 = meta:get_int("input1") == 1
-		local val2 = meta:get_int("input2") == 1
+		-- Inputs are stored in param2. Bit 5 is always set.
+		-- input1 is bit 6 and input2 is bit 7.
+		local val1, val2
+		if node.param2 >= 32 then
+			-- Bit 5 is set, so param2 is in the proper format.
+			if link.name == "input1" then
+				val1 = newstate == "on"
+				val2 = node.param2 >= 128
+			else
+				val1 = node.param2 % 128 >= 64
+				val2 = newstate == "on"
+			end
+		else
+			-- Migrate old gates where the inputs are stored as metadata.
+			-- This also triggers for newly placed gates.
+			local meta = minetest.get_meta(pos)
+			if link.name == "input1" then
+				val1 = newstate == "on"
+				val2 = meta:get_int("input2") == 1
+			else
+				val1 = meta:get_int("input1") == 1
+				val2 = newstate == "on"
+			end
+			-- Set bit 5 so this won't happen again.
+			node.param2 = node.param2 + 32
+			-- Clear the metadata.
+			meta:set_string("input1", "")
+			meta:set_string("input2", "")
+		end
+		node.param2 = node.param2 % 64 + (val1 and 64 or 0) + (val2 and 128 or 0)
 		set_gate(pos, node, gate.assess(val1, val2))
 	end
 end
@@ -65,7 +81,6 @@ end
 local function register_gate(name, inputnumber, assess, recipe, description)
 	local get_inputrules = inputnumber == 2 and gate_get_input_rules_twoinputs or
 		gate_get_input_rules_oneinput
-	description = "Logic Gate: "..name
 
 	local basename = "mesecons_gates:"..name
 	mesecon.register_node(basename, {
@@ -79,12 +94,13 @@ local function register_gate(name, inputnumber, assess, recipe, description)
 		selection_box = selection_box,
 		node_box = nodebox,
 		walkable = true,
-		sounds = default.node_sound_stone_defaults(),
+		sounds = mesecon.node_sound.stone,
 		assess = assess,
 		onstate = basename.."_on",
 		offstate = basename.."_off",
 		inputnumber = inputnumber,
 		after_dig_node = mesecon.do_cooldown,
+		on_rotate = mesecon.on_rotate_horiz,
 	},{
 		tiles = {
 			"jeija_microcontroller_bottom.png^".."jeija_gate_off.png^"..

mesecons_gates/mod.conf

@@ -1,2 +1,2 @@
 name = mesecons_gates
-depends = mesecons, mesecons_microcontroller, mesecons_delayer, mesecons_torch, mesecons_materials
+depends = mesecons, mesecons_gamecompat, mesecons_microcontroller, mesecons_delayer, mesecons_torch, mesecons_materials

mesecons_hydroturbine/init.lua

@@ -1,3 +1,5 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
 -- HYDRO_TURBINE
 -- Water turbine:
 -- Active if flowing >water< above it
@@ -12,17 +14,18 @@ minetest.register_node("mesecons_hydroturbine:hydro_turbine_off", {
 		"jeija_hydro_turbine_turbine_top_bottom_off.png",
 		"jeija_hydro_turbine_turbine_misc_off.png"
 	},
+	use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "opaque" or nil,
 	inventory_image = "jeija_hydro_turbine_inv.png",
 	is_ground_content = false,
 	wield_scale = {x=0.75, y=0.75, z=0.75},
 	groups = {dig_immediate=2},
-	description="Water Turbine",
+	description = S("Water Turbine"),
 	paramtype = "light",
 	selection_box = {
 		type = "fixed",
 		fixed = { -0.5, -0.5, -0.5, 0.5, 1.5, 0.5 },
 	},
-	sounds = default.node_sound_metal_defaults(),
+	sounds = mesecon.node_sound.metal,
 	mesecons = {receptor = {
 		state = mesecon.state.off
 	}},
@@ -42,16 +45,17 @@ minetest.register_node("mesecons_hydroturbine:hydro_turbine_on", {
 		{ name = "jeija_hydro_turbine_turbine_misc_on.png",
 		    animation = {type = "vertical_frames", aspect_w = 256, aspect_h = 32, length = 0.4} }
 	},
+	use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "clip" or nil,
 	inventory_image = "jeija_hydro_turbine_inv.png",
 	drop = "mesecons_hydroturbine:hydro_turbine_off 1",
 	groups = {dig_immediate=2,not_in_creative_inventory=1},
-	description="Water Turbine",
+	description = S("Water Turbine"),
 	paramtype = "light",
 	selection_box = {
 		type = "fixed",
 		fixed = { -0.5, -0.5, -0.5, 0.5, 1.5, 0.5 },
 	},
-	sounds = default.node_sound_metal_defaults(),
+	sounds = mesecon.node_sound.metal,
 	mesecons = {receptor = {
 		state = mesecon.state.on
 	}},
@@ -62,15 +66,15 @@ minetest.register_node("mesecons_hydroturbine:hydro_turbine_on", {
 local function is_flowing_water(pos)
 	local name = minetest.get_node(pos).name
 	local is_water = minetest.get_item_group(name, "water") > 0
-	local is_flowing = minetest.registered_items[name].liquidtype == "flowing"
-	return (is_water and is_flowing)
+	local def = minetest.registered_items[name]
+	return is_water and (def and def.liquidtype == "flowing")
 end
 
 minetest.register_abm({
 nodenames = {"mesecons_hydroturbine:hydro_turbine_off"},
 	interval = 1,
 	chance = 1,
-	action = function(pos, node, active_object_count, active_object_count_wider)
+	action = function(pos)
 		local waterpos={x=pos.x, y=pos.y+1, z=pos.z}
 		if is_flowing_water(waterpos) then
 			minetest.set_node(pos, {name="mesecons_hydroturbine:hydro_turbine_on"})
@@ -83,7 +87,7 @@ minetest.register_abm({
 nodenames = {"mesecons_hydroturbine:hydro_turbine_on"},
 	interval = 1,
 	chance = 1,
-	action = function(pos, node, active_object_count, active_object_count_wider)
+	action = function(pos)
 		local waterpos={x=pos.x, y=pos.y+1, z=pos.z}
 		if not is_flowing_water(waterpos) then
 			minetest.set_node(pos, {name="mesecons_hydroturbine:hydro_turbine_off"})
@@ -95,9 +99,8 @@ nodenames = {"mesecons_hydroturbine:hydro_turbine_on"},
 minetest.register_craft({
 	output = "mesecons_hydroturbine:hydro_turbine_off 2",
 	recipe = {
-	{"","default:stick", ""},
-	{"default:stick", "default:steel_ingot", "default:stick"},
-	{"","default:stick", ""},
+	{"","group:stick", ""},
+	{"group:stick", "mesecons_gamecompat:steel_ingot", "group:stick"},
+	{"","group:stick", ""},
 	}
 })
-

mesecons_hydroturbine/locale/mesecons_hydroturbine.de.tr

@@ -0,0 +1,2 @@
+# textdomain: mesecons_hydroturbine
+Water Turbine=Wasserturbine

mesecons_hydroturbine/locale/mesecons_hydroturbine.eo.tr

@@ -0,0 +1,4 @@
+# textdomain: mesecons_hydroturbine
+
+### init.lua ###
+Water Turbine=Akva Turbino

mesecons_hydroturbine/locale/template.txt

@@ -0,0 +1,4 @@
+# textdomain: mesecons_hydroturbine
+
+### init.lua ###
+Water Turbine=

mesecons_hydroturbine/mod.conf

@@ -1,2 +1,2 @@
 name = mesecons_hydroturbine
-depends = mesecons
+depends = mesecons, mesecons_gamecompat

mesecons_insulated/init.lua

@@ -1,17 +1,13 @@
-local screwdriver_exists = minetest.global_exists("screwdriver")
+local S = minetest.get_translator(minetest.get_current_modname())
 
-local function insulated_wire_get_rules(node)
-	local rules = 	{{x = 1,  y = 0,  z = 0},
-			 {x =-1,  y = 0,  z = 0}}
-	if node.param2 == 1 or node.param2 == 3 then
-		return mesecon.rotate_rules_right(rules)
-	end
-	return rules
-end
+local insulated_wire_get_rules = mesecon.horiz_rules_getter({
+	{x = 1, y = 0, z = 0},
+	{x = -1, y = 0, z = 0},
+})
 
 minetest.register_node("mesecons_insulated:insulated_on", {
 	drawtype = "nodebox",
-	description = "Straight Insulated Mesecon",
+	description = S("Straight Insulated Mesecon"),
 	tiles = {
 		"jeija_insulated_wire_sides_on.png",
 		"jeija_insulated_wire_sides_on.png",
@@ -36,19 +32,19 @@ minetest.register_node("mesecons_insulated:insulated_on", {
 	},
 	groups = {dig_immediate = 3, not_in_creative_inventory = 1},
 	drop = "mesecons_insulated:insulated_off",
-	sounds = default.node_sound_defaults(),
+	sounds = mesecon.node_sound.default,
 	mesecons = {conductor = {
 		state = mesecon.state.on,
 		offstate = "mesecons_insulated:insulated_off",
 		rules = insulated_wire_get_rules
 	}},
 	on_blast = mesecon.on_blastnode,
-	on_rotate = screwdriver_exists and screwdriver.rotate_simple,
+	on_rotate = mesecon.on_rotate_horiz,
 })
 
 minetest.register_node("mesecons_insulated:insulated_off", {
 	drawtype = "nodebox",
-	description = "Straight Insulated Mesecon",
+	description = S("Straight Insulated Mesecon"),
 	tiles = {
 		"jeija_insulated_wire_sides_off.png",
 		"jeija_insulated_wire_sides_off.png",
@@ -72,21 +68,21 @@ minetest.register_node("mesecons_insulated:insulated_off", {
 		fixed = { -16/32-0.001, -17/32, -3/32, 16/32+0.001, -13/32, 3/32 }
 	},
 	groups = {dig_immediate = 3},
-	sounds = default.node_sound_defaults(),
+	sounds = mesecon.node_sound.default,
 	mesecons = {conductor = {
 		state = mesecon.state.off,
 		onstate = "mesecons_insulated:insulated_on",
 		rules = insulated_wire_get_rules
 	}},
 	on_blast = mesecon.on_blastnode,
-	on_rotate = screwdriver_exists and screwdriver.rotate_simple,
+	on_rotate = mesecon.on_rotate_horiz,
 })
 
 minetest.register_craft({
 	output = "mesecons_insulated:insulated_off 3",
 	recipe = {
 		{"mesecons_materials:fiber", "mesecons_materials:fiber", "mesecons_materials:fiber"},
-		{"mesecons:wire_00000000_off", "mesecons:wire_00000000_off", "mesecons:wire_00000000_off"},
+		{"group:mesecon_conductor_craftable", "group:mesecon_conductor_craftable", "group:mesecon_conductor_craftable"},
 		{"mesecons_materials:fiber", "mesecons_materials:fiber", "mesecons_materials:fiber"},
 	}
 })

mesecons_insulated/locale/mesecons_insulated.de.tr

@@ -0,0 +1,2 @@
+# textdomain: mesecons_insulated
+Straight Insulated Mesecon=Isolierte Mesecongerade

mesecons_insulated/locale/mesecons_insulated.eo.tr

@@ -0,0 +1,4 @@
+# textdomain: mesecons_insulated
+
+### init.lua ###
+Straight Insulated Mesecon=Rekta Izolita Mesekonduktilo

mesecons_insulated/locale/template.txt

@@ -0,0 +1,4 @@
+# textdomain: mesecons_insulated
+
+### init.lua ###
+Straight Insulated Mesecon=

mesecons_insulated/mod.conf

@@ -1,3 +1,2 @@
 name = mesecons_insulated
-depends = mesecons
-optional_depends = screwdriver
+depends = mesecons, mesecons_gamecompat

mesecons_lamp/init.lua

@@ -1,3 +1,5 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
 -- MESELAMPS
 -- A lamp is "is an electrical device used to create artificial light" (wikipedia)
 -- guess what?
@@ -9,9 +11,12 @@ local mesecon_lamp_box = {
 	wall_side = {-0.375,-0.3125,-0.3125,-0.5,0.3125,0.3125},
 }
 
+local use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "opaque" or nil
+
 minetest.register_node("mesecons_lamp:lamp_on", {
 	drawtype = "nodebox",
 	tiles = {"jeija_meselamp_on.png"},
+	use_texture_alpha = use_texture_alpha,
 	paramtype = "light",
 	paramtype2 = "wallmounted",
 	is_ground_content = false,
@@ -23,7 +28,7 @@ minetest.register_node("mesecons_lamp:lamp_on", {
 	selection_box = mesecon_lamp_box,
 	groups = {dig_immediate = 3,not_in_creative_inventory = 1, mesecon_effector_on = 1},
 	drop = "mesecons_lamp:lamp_off 1",
-	sounds = default.node_sound_glass_defaults(),
+	sounds = mesecon.node_sound.glass,
 	mesecons = {effector = {
 		action_off = function (pos, node)
 			minetest.swap_node(pos, {name = "mesecons_lamp:lamp_off", param2 = node.param2})
@@ -36,6 +41,7 @@ minetest.register_node("mesecons_lamp:lamp_on", {
 minetest.register_node("mesecons_lamp:lamp_off", {
 	drawtype = "nodebox",
 	tiles = {"jeija_meselamp_off.png"},
+	use_texture_alpha = use_texture_alpha,
 	inventory_image = "jeija_meselamp.png",
 	wield_image = "jeija_meselamp.png",
 	paramtype = "light",
@@ -46,8 +52,8 @@ minetest.register_node("mesecons_lamp:lamp_off", {
 	node_box = mesecon_lamp_box,
 	selection_box = mesecon_lamp_box,
 	groups = {dig_immediate=3, mesecon_receptor_off = 1, mesecon_effector_off = 1},
-	description = "Mesecon Lamp",
-	sounds = default.node_sound_glass_defaults(),
+	description = S("Mesecon Lamp"),
+	sounds = mesecon.node_sound.glass,
 	mesecons = {effector = {
 		action_on = function (pos, node)
 			minetest.swap_node(pos, {name = "mesecons_lamp:lamp_on", param2 = node.param2})
@@ -60,8 +66,8 @@ minetest.register_node("mesecons_lamp:lamp_off", {
 minetest.register_craft({
 	output = "mesecons_lamp:lamp_off 1",
 	recipe = {
-		{"", "default:glass", ""},
-		{"group:mesecon_conductor_craftable", "default:steel_ingot", "group:mesecon_conductor_craftable"},
-		{"", "default:glass", ""},
+		{"", "mesecons_gamecompat:glass", ""},
+		{"group:mesecon_conductor_craftable", "mesecons_gamecompat:steel_ingot", "group:mesecon_conductor_craftable"},
+		{"", "mesecons_gamecompat:glass", ""},
 	}
 })

mesecons_lamp/locale/mesecons_lamp.de.tr

@@ -0,0 +1,2 @@
+# textdomain: mesecons_lamp
+Mesecon Lamp=Meseconlampe

mesecons_lamp/locale/mesecons_lamp.eo.tr

@@ -0,0 +1,4 @@
+# textdomain: mesecons_lamp
+
+### init.lua ###
+Mesecon Lamp=Mesekonduktila Lampo

mesecons_lamp/locale/template.txt

@@ -0,0 +1,4 @@
+# textdomain: mesecons_lamp
+
+### init.lua ###
+Mesecon Lamp=

mesecons_lamp/mod.conf

@@ -1,2 +1,2 @@
 name = mesecons_lamp
-depends = mesecons
+depends = mesecons, mesecons_gamecompat

mesecons_lightstone/init.lua

@@ -1,3 +1,5 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
 local lightstone_rules = {
 	{x=0,  y=0,  z=-1},
 	{x=1,  y=0,  z=0},
@@ -23,7 +25,7 @@ function mesecon.lightstone_add(name, base_item, texture_off, texture_on, desc)
 		is_ground_content = false,
 		groups = {cracky = 2, mesecon_effector_off = 1, mesecon = 2},
 		description = desc,
-		sounds = default.node_sound_stone_defaults(),
+		sounds = mesecon.node_sound.stone,
 		mesecons = {effector = {
 			rules = lightstone_rules,
 			action_on = function (pos, node)
@@ -38,7 +40,7 @@ function mesecon.lightstone_add(name, base_item, texture_off, texture_on, desc)
 		groups = {cracky = 2, not_in_creative_inventory = 1, mesecon = 2},
 		drop = "mesecons_lightstone:lightstone_" .. name .. "_off",
 		light_source = minetest.LIGHT_MAX - 2,
-		sounds = default.node_sound_stone_defaults(),
+		sounds = mesecon.node_sound.stone,
 		mesecons = {effector = {
 			rules = lightstone_rules,
 			action_off = function (pos, node)
@@ -52,22 +54,22 @@ function mesecon.lightstone_add(name, base_item, texture_off, texture_on, desc)
 		output = "mesecons_lightstone:lightstone_" .. name .. "_off",
 		recipe = {
 			{"",base_item,""},
-			{base_item,"default:torch",base_item},
+			{base_item,"mesecons_gamecompat:torch",base_item},
 			{"","group:mesecon_conductor_craftable",""}
 		}
 	})
 end
 
 
-mesecon.lightstone_add("red", "dye:red", "jeija_lightstone_red_off.png", "jeija_lightstone_red_on.png", "Red Lightstone")
-mesecon.lightstone_add("green", "dye:green", "jeija_lightstone_green_off.png", "jeija_lightstone_green_on.png", "Green Lightstone")
-mesecon.lightstone_add("blue", "dye:blue", "jeija_lightstone_blue_off.png", "jeija_lightstone_blue_on.png", "Blue Lightstone")
-mesecon.lightstone_add("gray", "dye:grey", "jeija_lightstone_gray_off.png", "jeija_lightstone_gray_on.png", "Grey Lightstone")
-mesecon.lightstone_add("darkgray", "dye:dark_grey", "jeija_lightstone_darkgray_off.png", "jeija_lightstone_darkgray_on.png", "Dark Grey Lightstone")
-mesecon.lightstone_add("yellow", "dye:yellow", "jeija_lightstone_yellow_off.png", "jeija_lightstone_yellow_on.png", "Yellow Lightstone")
-mesecon.lightstone_add("orange", "dye:orange", "jeija_lightstone_orange_off.png", "jeija_lightstone_orange_on.png", "Orange Lightstone")
-mesecon.lightstone_add("white", "dye:white", "jeija_lightstone_white_off.png", "jeija_lightstone_white_on.png", "White Lightstone")
-mesecon.lightstone_add("pink", "dye:pink", "jeija_lightstone_pink_off.png", "jeija_lightstone_pink_on.png", "Pink Lightstone")
-mesecon.lightstone_add("magenta", "dye:magenta", "jeija_lightstone_magenta_off.png", "jeija_lightstone_magenta_on.png", "Magenta Lightstone")
-mesecon.lightstone_add("cyan", "dye:cyan", "jeija_lightstone_cyan_off.png", "jeija_lightstone_cyan_on.png", "Cyan Lightstone")
-mesecon.lightstone_add("violet", "dye:violet", "jeija_lightstone_violet_off.png", "jeija_lightstone_violet_on.png", "Violet Lightstone")
+mesecon.lightstone_add("red", "mesecons_gamecompat:dye_red", "jeija_lightstone_red_off.png", "jeija_lightstone_red_on.png", S("Red Lightstone"))
+mesecon.lightstone_add("green", "mesecons_gamecompat:dye_green", "jeija_lightstone_green_off.png", "jeija_lightstone_green_on.png", S("Green Lightstone"))
+mesecon.lightstone_add("blue", "mesecons_gamecompat:dye_blue", "jeija_lightstone_blue_off.png", "jeija_lightstone_blue_on.png", S("Blue Lightstone"))
+mesecon.lightstone_add("gray", "mesecons_gamecompat:dye_grey", "jeija_lightstone_gray_off.png", "jeija_lightstone_gray_on.png", S("Grey Lightstone"))
+mesecon.lightstone_add("darkgray", "mesecons_gamecompat:dye_dark_grey", "jeija_lightstone_darkgray_off.png", "jeija_lightstone_darkgray_on.png", S("Dark Grey Lightstone"))
+mesecon.lightstone_add("yellow", "mesecons_gamecompat:dye_yellow", "jeija_lightstone_yellow_off.png", "jeija_lightstone_yellow_on.png", S("Yellow Lightstone"))
+mesecon.lightstone_add("orange", "mesecons_gamecompat:dye_orange", "jeija_lightstone_orange_off.png", "jeija_lightstone_orange_on.png", S("Orange Lightstone"))
+mesecon.lightstone_add("white", "mesecons_gamecompat:dye_white", "jeija_lightstone_white_off.png", "jeija_lightstone_white_on.png", S("White Lightstone"))
+mesecon.lightstone_add("pink", "mesecons_gamecompat:dye_pink", "jeija_lightstone_pink_off.png", "jeija_lightstone_pink_on.png", S("Pink Lightstone"))
+mesecon.lightstone_add("magenta", "mesecons_gamecompat:dye_magenta", "jeija_lightstone_magenta_off.png", "jeija_lightstone_magenta_on.png", S("Magenta Lightstone"))
+mesecon.lightstone_add("cyan", "mesecons_gamecompat:dye_cyan", "jeija_lightstone_cyan_off.png", "jeija_lightstone_cyan_on.png", S("Cyan Lightstone"))
+mesecon.lightstone_add("violet", "mesecons_gamecompat:dye_violet", "jeija_lightstone_violet_off.png", "jeija_lightstone_violet_on.png", S("Violet Lightstone"))

mesecons_lightstone/locale/mesecons_lightstone.de.tr

@@ -0,0 +1,13 @@
+# textdomain: mesecons_lightstone
+Red Lightstone=Roter Leuchtstein
+Green Lightstone=Grüner Leuchtstein
+Blue Lightstone=Blauer Leuchtstein
+Grey Lightstone=Grauer Leuchtstein
+Dark Grey Lightstone=Dunkelgrauer Leuchtstein
+Yellow Lightstone=Gelber Leuchtstein
+Orange Lightstone=Orange Leuchtstein
+White Lightstone=Weißer Leuchtstein
+Pink Lightstone=Rosa Leuchtstein
+Magenta Lightstone=Magenta Leuchtstein
+Cyan Lightstone=Türkiser Leuchtstein
+Violet Lightstone=Violetter Leuchtstein

mesecons_lightstone/locale/mesecons_lightstone.eo.tr

@@ -0,0 +1,15 @@
+# textdomain: mesecons_lightstone
+
+### init.lua ###
+Red Lightstone=Ruĝa Lumŝtono
+Green Lightstone=Verda Lumŝtono
+Blue Lightstone=Blua Lumŝtono
+Grey Lightstone=Griza Lumŝtono
+Dark Grey Lightstone=Malhela Griza Lumŝtono
+Yellow Lightstone=Flava Lumŝtono
+Orange Lightstone=Oranĝa Lumŝtono
+White Lightstone=Blanka Lumŝtono
+Pink Lightstone=Rozkolora Lumŝtono
+Magenta Lightstone=Magenta Lumŝtono
+Cyan Lightstone=Cejana Lumŝtono
+Violet Lightstone=Viola Lumŝtono

mesecons_lightstone/locale/template.txt

@@ -0,0 +1,15 @@
+# textdomain: mesecons_lightstone
+
+### init.lua ###
+Red Lightstone=
+Green Lightstone=
+Blue Lightstone=
+Grey Lightstone=
+Dark Grey Lightstone=
+Yellow Lightstone=
+Orange Lightstone=
+White Lightstone=
+Pink Lightstone=
+Magenta Lightstone=
+Cyan Lightstone=
+Violet Lightstone=

mesecons_lightstone/mod.conf

@@ -1,2 +1,2 @@
 name = mesecons_lightstone
-depends = mesecons, dye
+depends = mesecons, mesecons_gamecompat