minetest-mods
/
mesecons
mirror of https://github.com/minetest-mods/mesecons.git
1
0
Fork 2
Code Issues Releases Wiki Activity

Replace mesecon:<some_function> with mesecon.<some_function> for greater 

flexibility and because it was never inteded to be OOP in the first
place.

mesecon.receptor_on and mesecon.receptor_off are provided by wrappers
(mesecon:receptor_on/off) for compatibility, but will be removed. Mod
programmers that use mesecons: Please update!

Also, fix microcontroller polluting the global namespace and remove some
deprecated stuff.
This commit is contained in:
Jeija 2014-11-22 15:42:22 +01:00
parent ffacbfde5a
commit 5be179bf11
31 changed files with 455 additions and 488 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
mesecons/actionqueue.lua
View File

@ -12,19 +12,19 @@ function mesecon.queue:add_action(pos, func, params, time, overwritecheck, prior
-- Create Action Table:
time = time or 0 -- time <= 0 --> execute, time > 0 --> wait time until execution
priority = priority or 1
local action = { pos=mesecon:tablecopy(pos),
local action = { pos=mesecon.tablecopy(pos),
func=func,
params=mesecon:tablecopy(params or {}),
params=mesecon.tablecopy(params or {}),
time=time,
owcheck=(overwritecheck and mesecon:tablecopy(overwritecheck)) or nil,
owcheck=(overwritecheck and mesecon.tablecopy(overwritecheck)) or nil,
priority=priority}
local toremove = nil
-- Otherwise, add the action to the queue
if overwritecheck then -- check if old action has to be overwritten / removed:
for i, ac in ipairs(mesecon.queue.actions) do
if(mesecon:cmpPos(pos, ac.pos)
and mesecon:cmpAny(overwritecheck, ac.owcheck)) then
if(mesecon.cmpPos(pos, ac.pos)
and mesecon.cmpAny(overwritecheck, ac.owcheck)) then
toremove = i
break
end
@ -60,7 +60,7 @@ local m_time = 0
minetest.register_globalstep(function (dtime)
m_time = m_time + dtime
if (m_time < MESECONS_RESUMETIME) then return end -- don't even try if server has not been running for XY seconds
local actions = mesecon:tablecopy(mesecon.queue.actions)
local actions = mesecon.tablecopy(mesecon.queue.actions)
local actions_now={}
mesecon.queue.actions = {}

32
mesecons/init.lua
View File

@ -78,8 +78,8 @@ mesecon.queue:add_function("receptor_on", function (pos, rules)
rules = rules or mesecon.rules.default
-- if area (any of the rule targets) is not loaded, keep trying and call this again later
for _, rule in ipairs(mesecon:flattenrules(rules)) do
local np = mesecon:addPosRule(pos, rule)
for _, rule in ipairs(mesecon.flattenrules(rules)) do
local np = mesecon.addPosRule(pos, rule)
-- if area is not loaded, keep trying
if minetest.get_node_or_nil(np) == nil then
mesecon.queue:add_action(pos, "receptor_on", {rules}, nil, rules)
@ -88,16 +88,16 @@ mesecon.queue:add_function("receptor_on", function (pos, rules)
end
-- execute action
for _, rule in ipairs(mesecon:flattenrules(rules)) do
local np = mesecon:addPosRule(pos, rule)
local rulenames = mesecon:rules_link_rule_all(pos, rule)
for _, rule in ipairs(mesecon.flattenrules(rules)) do
local np = mesecon.addPosRule(pos, rule)
local rulenames = mesecon.rules_link_rule_all(pos, rule)
for _, rulename in ipairs(rulenames) do
mesecon:turnon(np, rulename)
mesecon.turnon(np, rulename)
end
end
end)
function mesecon:receptor_on(pos, rules)
function mesecon.receptor_on(pos, rules)
mesecon.queue:add_action(pos, "receptor_on", {rules}, nil, rules)
end
@ -105,28 +105,28 @@ mesecon.queue:add_function("receptor_off", function (pos, rules)
rules = rules or mesecon.rules.default
-- if area (any of the rule targets) is not loaded, keep trying and call this again later
for _, rule in ipairs(mesecon:flattenrules(rules)) do
local np = mesecon:addPosRule(pos, rule)
for _, rule in ipairs(mesecon.flattenrules(rules)) do
local np = mesecon.addPosRule(pos, rule)
if minetest.get_node_or_nil(np) == nil then
mesecon.queue:add_action(pos, "receptor_off", {rules}, nil, rules)
return
end
end
for _, rule in ipairs(mesecon:flattenrules(rules)) do
local np = mesecon:addPosRule(pos, rule)
local rulenames = mesecon:rules_link_rule_all(pos, rule)
for _, rule in ipairs(mesecon.flattenrules(rules)) do
local np = mesecon.addPosRule(pos, rule)
local rulenames = mesecon.rules_link_rule_all(pos, rule)
for _, rulename in ipairs(rulenames) do
if not mesecon:connected_to_receptor(np, mesecon:invertRule(rule)) then
mesecon:turnoff(np, rulename)
if not mesecon.connected_to_receptor(np, mesecon.invertRule(rule)) then
mesecon.turnoff(np, rulename)
else
mesecon:changesignal(np, minetest.get_node(np), rulename, mesecon.state.off, 2)
mesecon.changesignal(np, minetest.get_node(np), rulename, mesecon.state.off, 2)
end
end
end
end)
function mesecon:receptor_off(pos, rules)
function mesecon.receptor_off(pos, rules)
mesecon.queue:add_action(pos, "receptor_off", {rules}, nil, rules)
end

373
mesecons/internal.lua
View File

@ -3,56 +3,56 @@
-- For more practical developer resources see mesecons.tk
--
-- Function overview
-- mesecon:get_effector(nodename) --> Returns the mesecons.effector -specifictation in the nodedef by the nodename
-- mesecon:get_receptor(nodename) --> Returns the mesecons.receptor -specifictation in the nodedef by the nodename
-- mesecon:get_conductor(nodename) --> Returns the mesecons.conductor-specifictation in the nodedef by the nodename
-- mesecon:get_any_inputrules (node) --> Returns the rules of a node if it is a conductor or an effector
-- mesecon:get_any_outputrules (node) --> Returns the rules of a node if it is a conductor or a receptor
-- mesecon.get_effector(nodename) --> Returns the mesecons.effector -specifictation in the nodedef by the nodename
-- mesecon.get_receptor(nodename) --> Returns the mesecons.receptor -specifictation in the nodedef by the nodename
-- mesecon.get_conductor(nodename) --> Returns the mesecons.conductor-specifictation in the nodedef by the nodename
-- mesecon.get_any_inputrules (node) --> Returns the rules of a node if it is a conductor or an effector
-- mesecon.get_any_outputrules (node) --> Returns the rules of a node if it is a conductor or a receptor
-- RECEPTORS
-- mesecon:is_receptor(nodename) --> Returns true if nodename is a receptor
-- mesecon:is_receptor_on(nodename) --> Returns true if nodename is an receptor with state = mesecon.state.on
-- mesecon:is_receptor_off(nodename) --> Returns true if nodename is an receptor with state = mesecon.state.off
-- mesecon:receptor_get_rules(node) --> Returns the rules of the receptor (mesecon.rules.default if none specified)
-- mesecon.is_receptor(nodename) --> Returns true if nodename is a receptor
-- mesecon.is_receptor_on(nodename) --> Returns true if nodename is an receptor with state = mesecon.state.on
-- mesecon.is_receptor_off(nodename) --> Returns true if nodename is an receptor with state = mesecon.state.off
-- mesecon.receptor_get_rules(node) --> Returns the rules of the receptor (mesecon.rules.default if none specified)
-- EFFECTORS
-- mesecon:is_effector(nodename) --> Returns true if nodename is an effector
-- mesecon:is_effector_on(nodename) --> Returns true if nodename is an effector with nodedef.mesecons.effector.action_off
-- mesecon:is_effector_off(nodename) --> Returns true if nodename is an effector with nodedef.mesecons.effector.action_on
-- mesecon:effector_get_rules(node) --> Returns the input rules of the effector (mesecon.rules.default if none specified)
-- mesecon.is_effector(nodename) --> Returns true if nodename is an effector
-- mesecon.is_effector_on(nodename) --> Returns true if nodename is an effector with nodedef.mesecons.effector.action_off
-- mesecon.is_effector_off(nodename) --> Returns true if nodename is an effector with nodedef.mesecons.effector.action_on
-- mesecon.effector_get_rules(node) --> Returns the input rules of the effector (mesecon.rules.default if none specified)
-- SIGNALS
-- mesecon:activate(pos, node, depth) --> Activates the effector node at the specific pos (calls nodedef.mesecons.effector.action_on), higher depths are executed later
-- mesecon:deactivate(pos, node, depth) --> Deactivates the effector node at the specific pos (calls nodedef.mesecons.effector.action_off), higher depths are executed later
-- mesecon:changesignal(pos, node, rulename, newstate, depth) --> Changes the effector node at the specific pos (calls nodedef.mesecons.effector.action_change), higher depths are executed later
-- mesecon.activate(pos, node, depth) --> Activates the effector node at the specific pos (calls nodedef.mesecons.effector.action_on), higher depths are executed later
-- mesecon.deactivate(pos, node, depth) --> Deactivates the effector node at the specific pos (calls nodedef.mesecons.effector.action_off), higher depths are executed later
-- mesecon.changesignal(pos, node, rulename, newstate, depth) --> Changes the effector node at the specific pos (calls nodedef.mesecons.effector.action_change), higher depths are executed later
-- CONDUCTORS
-- mesecon:is_conductor(nodename) --> Returns true if nodename is a conductor
-- mesecon:is_conductor_on(node) --> Returns true if node is a conductor with state = mesecon.state.on
-- mesecon:is_conductor_off(node) --> Returns true if node is a conductor with state = mesecon.state.off
-- mesecon:get_conductor_on(node_off) --> Returns the onstate nodename of the conductor
-- mesecon:get_conductor_off(node_on) --> Returns the offstate nodename of the conductor
-- mesecon:conductor_get_rules(node) --> Returns the input+output rules of a conductor (mesecon.rules.default if none specified)
-- mesecon.is_conductor(nodename) --> Returns true if nodename is a conductor
-- mesecon.is_conductor_on(node) --> Returns true if node is a conductor with state = mesecon.state.on
-- mesecon.is_conductor_off(node) --> Returns true if node is a conductor with state = mesecon.state.off
-- mesecon.get_conductor_on(node_off) --> Returns the onstate nodename of the conductor
-- mesecon.get_conductor_off(node_on) --> Returns the offstate nodename of the conductor
-- mesecon.conductor_get_rules(node) --> Returns the input+output rules of a conductor (mesecon.rules.default if none specified)
-- HIGH-LEVEL Internals
-- mesecon:is_power_on(pos) --> Returns true if pos emits power in any way
-- mesecon:is_power_off(pos) --> Returns true if pos does not emit power in any way
-- mesecon:turnon(pos, rulename) --> Returns true whatever there is at pos. Calls itself for connected nodes (if pos is a conductor) --> recursive, the rulename is the name of the input rule that caused calling turnon; Uses third parameter recdepth internally to determine how far away the current node is from the initial pos as it uses recursion
-- mesecon:turnoff(pos, rulename) --> Turns off whatever there is at pos. Calls itself for connected nodes (if pos is a conductor) --> recursive, the rulename is the name of the input rule that caused calling turnoff; Uses third parameter recdepth internally to determine how far away the current node is from the initial pos as it uses recursion
-- mesecon:connected_to_receptor(pos) --> Returns true if pos is connected to a receptor directly or via conductors; calls itself if pos is a conductor --> recursive
-- mesecon:rules_link(output, input, dug_outputrules) --> Returns true if outputposition + outputrules = inputposition and inputposition + inputrules = outputposition (if the two positions connect)
-- mesecon:rules_link_anydir(outp., inp., d_outpr.) --> Same as rules mesecon:rules_link but also returns true if output and input are swapped
-- mesecon:is_powered(pos) --> Returns true if pos is powered by a receptor or a conductor
-- mesecon.is_power_on(pos) --> Returns true if pos emits power in any way
-- mesecon.is_power_off(pos) --> Returns true if pos does not emit power in any way
-- mesecon.turnon(pos, rulename) --> Returns true whatever there is at pos. Calls itself for connected nodes (if pos is a conductor) --> recursive, the rulename is the name of the input rule that caused calling turnon; Uses third parameter recdepth internally to determine how far away the current node is from the initial pos as it uses recursion
-- mesecon.turnoff(pos, rulename) --> Turns off whatever there is at pos. Calls itself for connected nodes (if pos is a conductor) --> recursive, the rulename is the name of the input rule that caused calling turnoff; Uses third parameter recdepth internally to determine how far away the current node is from the initial pos as it uses recursion
-- mesecon.connected_to_receptor(pos) --> Returns true if pos is connected to a receptor directly or via conductors; calls itself if pos is a conductor --> recursive
-- mesecon.rules_link(output, input, dug_outputrules) --> Returns true if outputposition + outputrules = inputposition and inputposition + inputrules = outputposition (if the two positions connect)
-- mesecon.rules_link_anydir(outp., inp., d_outpr.) --> Same as rules mesecon.rules_link but also returns true if output and input are swapped
-- mesecon.is_powered(pos) --> Returns true if pos is powered by a receptor or a conductor
-- RULES ROTATION helpsers
-- mesecon:rotate_rules_right(rules)
-- mesecon:rotate_rules_left(rules)
-- mesecon:rotate_rules_up(rules)
-- mesecon:rotate_rules_down(rules)
-- mesecon.rotate_rules_right(rules)
-- mesecon.rotate_rules_left(rules)
-- mesecon.rotate_rules_up(rules)
-- mesecon.rotate_rules_down(rules)
-- These functions return rules that have been rotated in the specific direction
-- General
function mesecon:get_effector(nodename)
function mesecon.get_effector(nodename)
if minetest.registered_nodes[nodename]
and minetest.registered_nodes[nodename].mesecons
and minetest.registered_nodes[nodename].mesecons.effector then
@ -60,7 +60,7 @@ function mesecon:get_effector(nodename)
end
end
function mesecon:get_receptor(nodename)
function mesecon.get_receptor(nodename)
if minetest.registered_nodes[nodename]
and minetest.registered_nodes[nodename].mesecons
and minetest.registered_nodes[nodename].mesecons.receptor then
@ -68,7 +68,7 @@ function mesecon:get_receptor(nodename)
end
end
function mesecon:get_conductor(nodename)
function mesecon.get_conductor(nodename)
if minetest.registered_nodes[nodename]
and minetest.registered_nodes[nodename].mesecons
and minetest.registered_nodes[nodename].mesecons.conductor then
@ -76,52 +76,52 @@ function mesecon:get_conductor(nodename)
end
end
function mesecon:get_any_outputrules (node)
if mesecon:is_conductor(node.name) then
return mesecon:conductor_get_rules(node)
elseif mesecon:is_receptor(node.name) then
return mesecon:receptor_get_rules(node)
function mesecon.get_any_outputrules (node)
if mesecon.is_conductor(node.name) then
return mesecon.conductor_get_rules(node)
elseif mesecon.is_receptor(node.name) then
return mesecon.receptor_get_rules(node)
end
return false
end
function mesecon:get_any_inputrules (node)
if mesecon:is_conductor(node.name) then
return mesecon:conductor_get_rules(node)
elseif mesecon:is_effector(node.name) then
return mesecon:effector_get_rules(node)
function mesecon.get_any_inputrules (node)
if mesecon.is_conductor(node.name) then
return mesecon.conductor_get_rules(node)
elseif mesecon.is_effector(node.name) then
return mesecon.effector_get_rules(node)
end
return false
end
-- Receptors
-- Nodes that can power mesecons
function mesecon:is_receptor_on(nodename)
local receptor = mesecon:get_receptor(nodename)
function mesecon.is_receptor_on(nodename)
local receptor = mesecon.get_receptor(nodename)
if receptor and receptor.state == mesecon.state.on then
return true
end
return false
end
function mesecon:is_receptor_off(nodename)
local receptor = mesecon:get_receptor(nodename)
function mesecon.is_receptor_off(nodename)
local receptor = mesecon.get_receptor(nodename)
if receptor and receptor.state == mesecon.state.off then
return true
end
return false
end
function mesecon:is_receptor(nodename)
local receptor = mesecon:get_receptor(nodename)
function mesecon.is_receptor(nodename)
local receptor = mesecon.get_receptor(nodename)
if receptor then
return true
end
return false
end
function mesecon:receptor_get_rules(node)
local receptor = mesecon:get_receptor(node.name)
function mesecon.receptor_get_rules(node)
local receptor = mesecon.get_receptor(node.name)
if receptor then
local rules = receptor.rules
if type(rules) == 'function' then
@ -136,32 +136,32 @@ end
-- Effectors
-- Nodes that can be powered by mesecons
function mesecon:is_effector_on(nodename)
local effector = mesecon:get_effector(nodename)
function mesecon.is_effector_on(nodename)
local effector = mesecon.get_effector(nodename)
if effector and effector.action_off then
return true
end
return false
end
function mesecon:is_effector_off(nodename)
local effector = mesecon:get_effector(nodename)
function mesecon.is_effector_off(nodename)
local effector = mesecon.get_effector(nodename)
if effector and effector.action_on then
return true
end
return false
end
function mesecon:is_effector(nodename)
local effector = mesecon:get_effector(nodename)
function mesecon.is_effector(nodename)
local effector = mesecon.get_effector(nodename)
if effector then
return true
end
return false
end
function mesecon:effector_get_rules(node)
local effector = mesecon:get_effector(node.name)
function mesecon.effector_get_rules(node)
local effector = mesecon.get_effector(node.name)
if effector then
local rules = effector.rules
if type(rules) == 'function' then
@ -180,17 +180,17 @@ end
-- Activation:
mesecon.queue:add_function("activate", function (pos, rulename)
node = minetest.get_node(pos)
effector = mesecon:get_effector(node.name)
effector = mesecon.get_effector(node.name)
if effector and effector.action_on then
effector.action_on(pos, node, rulename)
end
end)
function mesecon:activate(pos, node, rulename, depth)
function mesecon.activate(pos, node, rulename, depth)
if rulename == nil then
for _,rule in ipairs(mesecon:effector_get_rules(node)) do
mesecon:activate(pos, node, rule, depth + 1)
for _,rule in ipairs(mesecon.effector_get_rules(node)) do
mesecon.activate(pos, node, rule, depth + 1)
end
return
end
@ -201,17 +201,17 @@ end
-- Deactivation
mesecon.queue:add_function("deactivate", function (pos, rulename)
node = minetest.get_node(pos)
effector = mesecon:get_effector(node.name)
effector = mesecon.get_effector(node.name)
if effector and effector.action_off then
effector.action_off(pos, node, rulename)
end
end)
function mesecon:deactivate(pos, node, rulename, depth)
function mesecon.deactivate(pos, node, rulename, depth)
if rulename == nil then
for _,rule in ipairs(mesecon:effector_get_rules(node)) do
mesecon:deactivate(pos, node, rule, depth + 1)
for _,rule in ipairs(mesecon.effector_get_rules(node)) do
mesecon.deactivate(pos, node, rule, depth + 1)
end
return
end
@ -222,17 +222,17 @@ end
-- Change
mesecon.queue:add_function("change", function (pos, rulename, changetype)
local node = minetest.get_node(pos)
local effector = mesecon:get_effector(node.name)
local effector = mesecon.get_effector(node.name)
if effector and effector.action_change then
effector.action_change(pos, node, rulename, changetype)
end
end)
function mesecon:changesignal(pos, node, rulename, newstate, depth)
function mesecon.changesignal(pos, node, rulename, newstate, depth)
if rulename == nil then
for _,rule in ipairs(mesecon:effector_get_rules(node)) do
mesecon:changesignal(pos, node, rule, newstate, depth + 1)
for _,rule in ipairs(mesecon.effector_get_rules(node)) do
mesecon.changesignal(pos, node, rule, newstate, depth + 1)
end
return
end
@ -242,84 +242,84 @@ end
-- Conductors
function mesecon:is_conductor_on(node, rulename)
local conductor = mesecon:get_conductor(node.name)
function mesecon.is_conductor_on(node, rulename)
local conductor = mesecon.get_conductor(node.name)
if conductor then
if conductor.state then
return conductor.state == mesecon.state.on
end
if conductor.states then
if not rulename then
return mesecon:getstate(node.name, conductor.states) ~= 1
return mesecon.getstate(node.name, conductor.states) ~= 1
end
local bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node))
local binstate = mesecon:getbinstate(node.name, conductor.states)
return mesecon:get_bit(binstate, bit)
local bit = mesecon.rule2bit(rulename, mesecon.conductor_get_rules(node))
local binstate = mesecon.getbinstate(node.name, conductor.states)
return mesecon.get_bit(binstate, bit)
end
end
return false
end
function mesecon:is_conductor_off(node, rulename)
local conductor = mesecon:get_conductor(node.name)
function mesecon.is_conductor_off(node, rulename)
local conductor = mesecon.get_conductor(node.name)
if conductor then
if conductor.state then
return conductor.state == mesecon.state.off
end
if conductor.states then
if not rulename then
return mesecon:getstate(node.name, conductor.states) == 1
return mesecon.getstate(node.name, conductor.states) == 1
end
local bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node))
local binstate = mesecon:getbinstate(node.name, conductor.states)
return not mesecon:get_bit(binstate, bit)
local bit = mesecon.rule2bit(rulename, mesecon.conductor_get_rules(node))
local binstate = mesecon.getbinstate(node.name, conductor.states)
return not mesecon.get_bit(binstate, bit)
end
end
return false
end
function mesecon:is_conductor(nodename)
local conductor = mesecon:get_conductor(nodename)
function mesecon.is_conductor(nodename)
local conductor = mesecon.get_conductor(nodename)
if conductor then
return true
end
return false
end
function mesecon:get_conductor_on(node_off, rulename)
local conductor = mesecon:get_conductor(node_off.name)
function mesecon.get_conductor_on(node_off, rulename)
local conductor = mesecon.get_conductor(node_off.name)
if conductor then
if conductor.onstate then
return conductor.onstate
end
if conductor.states then
local bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node_off))
local binstate = mesecon:getbinstate(node_off.name, conductor.states)
binstate = mesecon:set_bit(binstate, bit, "1")
local bit = mesecon.rule2bit(rulename, mesecon.conductor_get_rules(node_off))
local binstate = mesecon.getbinstate(node_off.name, conductor.states)
binstate = mesecon.set_bit(binstate, bit, "1")
return conductor.states[tonumber(binstate,2)+1]
end
end
return offstate
end
function mesecon:get_conductor_off(node_on, rulename)
local conductor = mesecon:get_conductor(node_on.name)
function mesecon.get_conductor_off(node_on, rulename)
local conductor = mesecon.get_conductor(node_on.name)
if conductor then
if conductor.offstate then
return conductor.offstate
end
if conductor.states then
local bit = mesecon:rule2bit(rulename, mesecon:conductor_get_rules(node_on))
local binstate = mesecon:getbinstate(node_on.name, conductor.states)
binstate = mesecon:set_bit(binstate, bit, "0")
local bit = mesecon.rule2bit(rulename, mesecon.conductor_get_rules(node_on))
local binstate = mesecon.getbinstate(node_on.name, conductor.states)
binstate = mesecon.set_bit(binstate, bit, "0")
return conductor.states[tonumber(binstate,2)+1]
end
end
return onstate
end
function mesecon:conductor_get_rules(node)
local conductor = mesecon:get_conductor(node.name)
function mesecon.conductor_get_rules(node)
local conductor = mesecon.get_conductor(node.name)
if conductor then
local rules = conductor.rules
if type(rules) == 'function' then
@ -333,23 +333,23 @@ end
-- some more general high-level stuff
function mesecon:is_power_on(pos, rulename)
function mesecon.is_power_on(pos, rulename)
local node = minetest.get_node(pos)
if mesecon:is_conductor_on(node, rulename) or mesecon:is_receptor_on(node.name) then
if mesecon.is_conductor_on(node, rulename) or mesecon.is_receptor_on(node.name) then
return true
end
return false
end
function mesecon:is_power_off(pos, rulename)
function mesecon.is_power_off(pos, rulename)
local node = minetest.get_node(pos)
if mesecon:is_conductor_off(node, rulename) or mesecon:is_receptor_off(node.name) then
if mesecon.is_conductor_off(node, rulename) or mesecon.is_receptor_off(node.name) then
return true
end
return false
end
function mesecon:turnon(pos, link)
function mesecon.turnon(pos, link)
local frontiers = {{pos = pos, link = link}}
local depth = 1
@ -362,31 +362,31 @@ function mesecon:turnon(pos, link)
mesecon.queue:add_action(f.pos, "turnon", {link}, nil, true)
end
if mesecon:is_conductor_off(node, f.link) then
local rules = mesecon:conductor_get_rules(node)
if mesecon.is_conductor_off(node, f.link) then
local rules = mesecon.conductor_get_rules(node)
minetest.swap_node(f.pos, {name = mesecon:get_conductor_on(node, f.link),
minetest.swap_node(f.pos, {name = mesecon.get_conductor_on(node, f.link),
param2 = node.param2})
-- call turnon on neighbors: normal rules
for _, r in ipairs(mesecon:rule2meta(f.link, rules)) do
local np = mesecon:addPosRule(f.pos, r)
for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
local np = mesecon.addPosRule(f.pos, r)
-- area not loaded, postpone action
if not minetest.get_node_or_nil(np) then
mesecon.queue:add_action(np, "turnon", {rulename},
nil, true)
else
local links = mesecon:rules_link_rule_all(f.pos, r)
local links = mesecon.rules_link_rule_all(f.pos, r)
for _, l in ipairs(links) do
table.insert(frontiers, {pos = np, link = l})
end
end
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)
elseif mesecon.is_effector(node.name) then
mesecon.changesignal(f.pos, node, f.link, mesecon.state.on, depth)
if mesecon.is_effector_off(node.name) then
mesecon.activate(f.pos, node, f.link, depth)
end
end
depth = depth + 1
@ -394,10 +394,10 @@ function mesecon:turnon(pos, link)
end
mesecon.queue:add_function("turnon", function (pos, rulename, recdepth)
mesecon:turnon(pos, rulename, recdepth)
mesecon.turnon(pos, rulename, recdepth)
end)
function mesecon:turnoff(pos, link)
function mesecon.turnoff(pos, link)
local frontiers = {{pos = pos, link = link}}
local depth = 1
@ -410,31 +410,31 @@ function mesecon:turnoff(pos, link)
mesecon.queue:add_action(f.pos, "turnoff", {link}, nil, true)
end
if mesecon:is_conductor_on(node, f.link) then
local rules = mesecon:conductor_get_rules(node)
if mesecon.is_conductor_on(node, f.link) then
local rules = mesecon.conductor_get_rules(node)
minetest.swap_node(f.pos, {name = mesecon:get_conductor_off(node, f.link),
minetest.swap_node(f.pos, {name = mesecon.get_conductor_off(node, f.link),
param2 = node.param2})
-- call turnoff on neighbors: normal rules
for _, r in ipairs(mesecon:rule2meta(f.link, rules)) do
local np = mesecon:addPosRule(f.pos, r)
for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
local np = mesecon.addPosRule(f.pos, r)
-- area not loaded, postpone action
if not minetest.get_node_or_nil(np) then
mesecon.queue:add_action(np, "turnoff", {rulename},
nil, true)
else
local links = mesecon:rules_link_rule_all(f.pos, r)
local links = mesecon.rules_link_rule_all(f.pos, r)
for _, l in ipairs(links) do
table.insert(frontiers, {pos = np, link = l})
end
end
end
elseif mesecon:is_effector(node.name) then
mesecon:changesignal(f.pos, node, f.link, mesecon.state.off, depth)
if mesecon:is_effector_on(node.name) and not mesecon:is_powered(f.pos) then
mesecon:deactivate(f.pos, node, f.link, depth)
elseif mesecon.is_effector(node.name) then
mesecon.changesignal(f.pos, node, f.link, mesecon.state.off, depth)
if mesecon.is_effector_on(node.name) and not mesecon.is_powered(f.pos) then
mesecon.deactivate(f.pos, node, f.link, depth)
end
end
depth = depth + 1
@ -442,22 +442,22 @@ function mesecon:turnoff(pos, link)
end
mesecon.queue:add_function("turnoff", function (pos, rulename, recdepth)
mesecon:turnoff(pos, rulename, recdepth)
mesecon.turnoff(pos, rulename, recdepth)
end)
function mesecon:connected_to_receptor(pos, rulename)
function mesecon.connected_to_receptor(pos, rulename)
local node = minetest.get_node(pos)
-- Check if conductors around are connected
local rules = mesecon:get_any_inputrules(node)
local rules = mesecon.get_any_inputrules(node)
if not rules then return false end
for _, rule in ipairs(mesecon:rule2meta(rulename, rules)) do
local rulenames = mesecon:rules_link_rule_all_inverted(pos, rule)
for _, rule in ipairs(mesecon.rule2meta(rulename, rules)) do
local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
for _, rname in ipairs(rulenames) do
local np = mesecon:addPosRule(pos, rname)
if mesecon:find_receptor_on(np, {}, mesecon:invertRule(rname)) then
local np = mesecon.addPosRule(pos, rname)
if mesecon.find_receptor_on(np, {}, mesecon.invertRule(rname)) then
return true
end
end
@ -466,33 +466,34 @@ function mesecon:connected_to_receptor(pos, rulename)
return false
end
function mesecon:find_receptor_on(pos, checked, rulename, recdepth)
function mesecon.find_receptor_on(pos, checked, rulename, recdepth)
recdepth = recdepth or 2
if (recdepth > STACK_SIZE) then return true end -- ignore request
local node = minetest.get_node(pos)
if mesecon:is_receptor_on(node.name) then
if mesecon.is_receptor_on(node.name) then
-- add current position to checked
table.insert(checked, {x=pos.x, y=pos.y, z=pos.z})
return true
end
if mesecon:is_conductor(node.name) then
local rules = mesecon:conductor_get_rules(node)
local metaindex = mesecon:rule2metaindex(rulename, rules)
if mesecon.is_conductor(node.name) then
local rules = mesecon.conductor_get_rules(node)
local metaindex = mesecon.rule2metaindex(rulename, rules)
-- find out if node has already been checked (to prevent from endless loop)
for _, cp in ipairs(checked) do
if mesecon:cmpPos(cp, pos) and cp.metaindex == metaindex then
if mesecon.cmpPos(cp, pos) and cp.metaindex == metaindex then
return false, checked
end
end
-- add current position to checked
table.insert(checked, {x=pos.x, y=pos.y, z=pos.z, metaindex = metaindex})
for _, rule in ipairs(mesecon:rule2meta(rulename, rules)) do
local rulenames = mesecon:rules_link_rule_all_inverted(pos, rule)
for _, rule in ipairs(mesecon.rule2meta(rulename, rules)) do
local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
for _, rname in ipairs(rulenames) do
local np = mesecon:addPosRule(pos, rname)
if mesecon:find_receptor_on(np, checked, mesecon:invertRule(rname), recdepth + 1) then
local np = mesecon.addPosRule(pos, rname)
if mesecon.find_receptor_on(np, checked, mesecon.invertRule(rname),
recdepth + 1) then
return true
end
end
@ -500,7 +501,7 @@ function mesecon:find_receptor_on(pos, checked, rulename, recdepth)
else
-- find out if node has already been checked (to prevent from endless loop)
for _, cp in ipairs(checked) do
if mesecon:cmpPos(cp, pos) then
if mesecon.cmpPos(cp, pos) then
return false, checked
end
end
@ -510,22 +511,23 @@ function mesecon:find_receptor_on(pos, checked, rulename, recdepth)
return false
end
function mesecon:rules_link(output, input, dug_outputrules) --output/input are positions (outputrules optional, used if node has been dug), second return value: the name of the affected input rule
function mesecon.rules_link(output, input, dug_outputrules) --output/input are positions (outputrules optional, used if node has been dug), second return value: the name of the affected input rule
local outputnode = minetest.get_node(output)
local inputnode = minetest.get_node(input)
local outputrules = dug_outputrules or mesecon:get_any_outputrules (outputnode)
local inputrules = mesecon:get_any_inputrules (inputnode)
local outputrules = dug_outputrules or mesecon.get_any_outputrules (outputnode)
local inputrules = mesecon.get_any_inputrules (inputnode)
if not outputrules or not inputrules then
return
end
for _, outputrule in ipairs(mesecon:flattenrules(outputrules)) do
for _, outputrule in ipairs(mesecon.flattenrules(outputrules)) do
-- Check if output sends to input
if mesecon:cmpPos(mesecon:addPosRule(output, outputrule), input) then
for _, inputrule in ipairs(mesecon:flattenrules(inputrules)) do
if mesecon.cmpPos(mesecon.addPosRule(output, outputrule), input) then
for _, inputrule in ipairs(mesecon.flattenrules(inputrules)) do
-- Check if input accepts from output
if mesecon:cmpPos(mesecon:addPosRule(input, inputrule), output) then
if inputrule.sx == nil or outputrule.sx == nil or mesecon:cmpSpecial(inputrule, outputrule) then
if mesecon.cmpPos(mesecon.addPosRule(input, inputrule), output) then
if inputrule.sx == nil or outputrule.sx == nil
or mesecon.cmpSpecial(inputrule, outputrule) then
return true, inputrule
end
end
@ -535,19 +537,20 @@ function mesecon:rules_link(output, input, dug_outputrules) --output/input are p
return false
end
function mesecon:rules_link_rule_all(output, rule)
local input = mesecon:addPosRule(output, rule)
function mesecon.rules_link_rule_all(output, rule)
local input = mesecon.addPosRule(output, rule)
local inputnode = minetest.get_node(input)
local inputrules = mesecon:get_any_inputrules (inputnode)
local inputrules = mesecon.get_any_inputrules (inputnode)
if not inputrules then
return {}
end
local rules = {}
for _, inputrule in ipairs(mesecon:flattenrules(inputrules)) do
for _, inputrule in ipairs(mesecon.flattenrules(inputrules)) do
-- Check if input accepts from output
if mesecon:cmpPos(mesecon:addPosRule(input, inputrule), output) then
if inputrule.sx == nil or rule.sx == nil or mesecon:cmpSpecial(inputrule, rule) then
if mesecon.cmpPos(mesecon.addPosRule(input, inputrule), output) then
if inputrule.sx == nil or rule.sx == nil
or mesecon.cmpSpecial(inputrule, rule) then
rules[#rules+1] = inputrule
end
end
@ -555,56 +558,58 @@ function mesecon:rules_link_rule_all(output, rule)
return rules
end
function mesecon:rules_link_rule_all_inverted(input, rule)
--local irule = mesecon:invertRule(rule)
local output = mesecon:addPosRule(input, rule)
function mesecon.rules_link_rule_all_inverted(input, rule)
--local irule = mesecon.invertRule(rule)
local output = mesecon.addPosRule(input, rule)
local outputnode = minetest.get_node(output)
local outputrules = mesecon:get_any_outputrules (outputnode)
local outputrules = mesecon.get_any_outputrules (outputnode)
if not outputrules then
return {}
end
local rules = {}
for _, outputrule in ipairs(mesecon:flattenrules(outputrules)) do
if mesecon:cmpPos(mesecon:addPosRule(output, outputrule), input) then
if outputrule.sx == nil or rule.sx == nil or mesecon:cmpSpecial(outputrule, rule) then
rules[#rules+1] = mesecon:invertRule(outputrule)
for _, outputrule in ipairs(mesecon.flattenrules(outputrules)) do
if mesecon.cmpPos(mesecon.addPosRule(output, outputrule), input) then
if outputrule.sx == nil or rule.sx == nil
or mesecon.cmpSpecial(outputrule, rule) then
rules[#rules+1] = mesecon.invertRule(outputrule)
end
end
end
return rules
end
function mesecon:rules_link_anydir(pos1, pos2)
return mesecon:rules_link(pos1, pos2) or mesecon:rules_link(pos2, pos1)
function mesecon.rules_link_anydir(pos1, pos2)
return mesecon.rules_link(pos1, pos2) or mesecon.rules_link(pos2, pos1)
end
function mesecon:is_powered(pos, rule)
function mesecon.is_powered(pos, rule)
local node = minetest.get_node(pos)
local rules = mesecon:get_any_inputrules(node)
local rules = mesecon.get_any_inputrules(node)
if not rules then return false end
-- List of nodes that send out power to pos
local sourcepos = {}
if not rule then
for _, rule in ipairs(mesecon:flattenrules(rules)) do
local rulenames = mesecon:rules_link_rule_all_inverted(pos, rule)
for _, rule in ipairs(mesecon.flattenrules(rules)) do
local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
for _, rname in ipairs(rulenames) do
local np = mesecon:addPosRule(pos, rname)
local np = mesecon.addPosRule(pos, rname)
local nn = minetest.get_node(np)
if (mesecon:is_conductor_on (nn, mesecon:invertRule(rname))
or mesecon:is_receptor_on (nn.name)) then
if (mesecon.is_conductor_on (nn, mesecon.invertRule(rname))
or mesecon.is_receptor_on (nn.name)) then
table.insert(sourcepos, np)
end
end
end
else
local rulenames = mesecon:rules_link_rule_all_inverted(pos, rule)
local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
for _, rname in ipairs(rulenames) do
local np = mesecon:addPosRule(pos, rname)
local np = mesecon.addPosRule(pos, rname)
local nn = minetest.get_node(np)
if (mesecon:is_conductor_on (nn, mesecon:invertRule(rname)) or mesecon:is_receptor_on (nn.name)) then
if (mesecon.is_conductor_on (nn, mesecon.invertRule(rname))
or mesecon.is_receptor_on (nn.name)) then
sourcepos.insert(np)
end
end
@ -616,7 +621,7 @@ function mesecon:is_powered(pos, rule)
end
--Rules rotation Functions:
function mesecon:rotate_rules_right(rules)
function mesecon.rotate_rules_right(rules)
local nr = {}
for i, rule in ipairs(rules) do
if rule.sx then
@ -637,7 +642,7 @@ function mesecon:rotate_rules_right(rules)
return nr
end
function mesecon:rotate_rules_left(rules)
function mesecon.rotate_rules_left(rules)
local nr = {}
for i, rule in ipairs(rules) do
if rule.sx then
@ -658,7 +663,7 @@ function mesecon:rotate_rules_left(rules)
return nr
end
function mesecon:rotate_rules_down(rules)
function mesecon.rotate_rules_down(rules)
local nr = {}
for i, rule in ipairs(rules) do
if rule.sx then
@ -679,7 +684,7 @@ function mesecon:rotate_rules_down(rules)
return nr
end
function mesecon:rotate_rules_up(rules)
function mesecon.rotate_rules_up(rules)
local nr = {}
for i, rule in ipairs(rules) do
if rule.sx then

33
mesecons/legacy.lua
View File

@ -1,32 +1,7 @@
minetest.swap_node = minetest.swap_node or function(pos, node)
local data = minetest.get_meta(pos):to_table()
minetest.add_node(pos, node)
minetest.get_meta(pos):from_table(data)
function mesecon:receptor_on(pos, rules)
mesecon.receptor_on(pos, rules)
end
local rules = {}
rules.a = {x = -1, y = 0, z = 0, name="A"}
rules.b = {x = 0, y = 0, z = 1, name="B"}
rules.c = {x = 1, y = 0, z = 0, name="C"}
rules.d = {x = 0, y = 0, z = -1, name="D"}
function legacy_update_ports(pos)
local meta = minetest.get_meta(pos)
L = {
a = mesecon:is_power_on(mesecon:addPosRule(pos, rules.a),
mesecon:invertRule(rules.a)) and
mesecon:rules_link(mesecon:addPosRule(pos, rules.a), pos),
b = mesecon:is_power_on(mesecon:addPosRule(pos, rules.b),
mesecon:invertRule(rules.b)) and
mesecon:rules_link(mesecon:addPosRule(pos, rules.b), pos),
c = mesecon:is_power_on(mesecon:addPosRule(pos, rules.c),
mesecon:invertRule(rules.c)) and
mesecon:rules_link(mesecon:addPosRule(pos, rules.c), pos),
d = mesecon:is_power_on(mesecon:addPosRule(pos, rules.d),
mesecon:invertRule(rules.d)) and
mesecon:rules_link(mesecon:addPosRule(pos, rules.d), pos),
}
local n = (L.a and 1 or 0) + (L.b and 2 or 0) + (L.c and 4 or 0) + (L.d and 8 or 0) + 1
meta:set_int("real_portstates", n)
return L
function mesecon:receptor_off(pos, rules)
mesecon.receptor_off(pos, rules)
end

6
mesecons/presets.lua
View File

@ -35,11 +35,11 @@ mesecon.rules.flat =
mesecon.rules.buttonlike_get = function(node)
local rules = mesecon.rules.buttonlike
if node.param2 == 2 then
rules=mesecon:rotate_rules_left(rules)
rules=mesecon.rotate_rules_left(rules)
elseif node.param2 == 3 then
rules=mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
rules=mesecon.rotate_rules_right(mesecon.rotate_rules_right(rules))
elseif node.param2 == 0 then
rules=mesecon:rotate_rules_right(rules)
rules=mesecon.rotate_rules_right(rules)
end
return rules
end

36
mesecons/services.lua
View File

@ -4,44 +4,44 @@ mesecon.on_placenode = function (pos, node)
mesecon.update_autoconnect(pos, node)
-- Receptors: Send on signal when active
if mesecon:is_receptor_on(node.name) then
mesecon:receptor_on(pos, mesecon:receptor_get_rules(node))
if mesecon.is_receptor_on(node.name) then
mesecon.receptor_on(pos, mesecon.receptor_get_rules(node))
end
-- Conductors: Send turnon signal when powered or replace by respective offstate conductor
-- if placed conductor is an onstate one
if mesecon:is_conductor(node.name) then
local sources = mesecon:is_powered(pos)
if mesecon.is_conductor(node.name) then
local sources = mesecon.is_powered(pos)
if sources then
-- also call receptor_on if itself is powered already, so that neighboring
-- conductors will be activated (when pushing an on-conductor with a piston)
for _, s in ipairs(sources) do
local rule = {x = pos.x - s.x, y = pos.y - s.y, z = pos.z - s.z}
mesecon:turnon(pos, rule)
mesecon.turnon(pos, rule)
end
--mesecon:receptor_on (pos, mesecon:conductor_get_rules(node))
elseif mesecon:is_conductor_on(node) then
minetest.swap_node(pos, {name = mesecon:get_conductor_off(node)})
--mesecon.receptor_on (pos, mesecon.conductor_get_rules(node))
elseif mesecon.is_conductor_on(node) then
minetest.swap_node(pos, {name = mesecon.get_conductor_off(node)})
end
end
-- Effectors: Send changesignal and activate or deactivate
if mesecon:is_effector(node.name) then
if mesecon:is_powered(pos) then
mesecon:changesignal(pos, node, mesecon:effector_get_rules(node), "on", 1)
mesecon:activate(pos, node, nil, 1)
if mesecon.is_effector(node.name) then
if mesecon.is_powered(pos) then
mesecon.changesignal(pos, node, mesecon.effector_get_rules(node), "on", 1)
mesecon.activate(pos, node, nil, 1)
else
mesecon:changesignal(pos, node, mesecon:effector_get_rules(node), "off", 1)
mesecon:deactivate(pos, node, nil, 1)
mesecon.changesignal(pos, node, mesecon.effector_get_rules(node), "off", 1)
mesecon.deactivate(pos, node, nil, 1)
end
end
end
mesecon.on_dignode = function (pos, node)
if mesecon:is_conductor_on(node) then
mesecon:receptor_off(pos, mesecon:conductor_get_rules(node))
elseif mesecon:is_receptor_on(node.name) then
mesecon:receptor_off(pos, mesecon:receptor_get_rules(node))
if mesecon.is_conductor_on(node) then
mesecon.receptor_off(pos, mesecon.conductor_get_rules(node))
elseif mesecon.is_receptor_on(node.name) then
mesecon.receptor_off(pos, mesecon.receptor_get_rules(node))
end
mesecon.queue:add_action(pos, "update_autoconnect", {node})
end

64
mesecons/util.lua
View File

@ -1,4 +1,4 @@
function mesecon:move_node(pos, newpos)
function mesecon.move_node(pos, newpos)
local node = minetest.get_node(pos)
local meta = minetest.get_meta(pos):to_table()
minetest.remove_node(pos)
@ -7,18 +7,18 @@ function mesecon:move_node(pos, newpos)
end
--[[ new functions:
mesecon:flattenrules(allrules)
mesecon:rule2bit(findrule, allrules)
mesecon:rule2meta(findrule, allrules)
mesecon.flattenrules(allrules)
mesecon.rule2bit(findrule, allrules)
mesecon.rule2meta(findrule, allrules)
dec2bin(n)
mesecon:getstate(nodename, states)
mesecon:getbinstate(nodename, states)
mesecon:get_bit(binary, bit)
mesecon:set_bit(binary, bit, value)
mesecon:invertRule(r)
mesecon.getstate(nodename, states)
mesecon.getbinstate(nodename, states)
mesecon.get_bit(binary, bit)
mesecon.set_bit(binary, bit, value)
mesecon.invertRule(r)
--]]
function mesecon:flattenrules(allrules)
function mesecon.flattenrules(allrules)
--[[
{
{
@ -53,7 +53,7 @@ function mesecon:flattenrules(allrules)
--]]
end
function mesecon:rule2bit(findrule, allrules)
function mesecon.rule2bit(findrule, allrules)
--get the bit of the metarule the rule is in, or bit 1
if (allrules[1] and
allrules[1].x) or
@ -62,14 +62,14 @@ function mesecon:rule2bit(findrule, allrules)
end
for m,metarule in ipairs( allrules) do
for _, rule in ipairs(metarule ) do
if mesecon:cmpPos(findrule, rule) and mesecon:cmpSpecial(findrule, rule) then
if mesecon.cmpPos(findrule, rule) and mesecon.cmpSpecial(findrule, rule) then
return m
end
end
end
end
function mesecon:rule2metaindex(findrule, allrules)
function mesecon.rule2metaindex(findrule, allrules)
--get the metarule the rule is in, or allrules
if allrules[1].x then
@ -77,20 +77,20 @@ function mesecon:rule2metaindex(findrule, allrules)
end
if not(findrule) then
return mesecon:flattenrules(allrules)
return mesecon.flattenrules(allrules)
end
for m, metarule in ipairs( allrules) do
for _, rule in ipairs(metarule ) do
if mesecon:cmpPos(findrule, rule) and mesecon:cmpSpecial(findrule, rule) then
if mesecon.cmpPos(findrule, rule) and mesecon.cmpSpecial(findrule, rule) then
return m
end
end
end
end
function mesecon:rule2meta(findrule, allrules)
local index = mesecon:rule2metaindex(findrule, allrules)
function mesecon.rule2meta(findrule, allrules)
local index = mesecon.rule2metaindex(findrule, allrules)
if index == nil then
if allrules[1].x then
return allrules
@ -119,7 +119,7 @@ else
end
end
function mesecon:getstate(nodename, states)
function mesecon.getstate(nodename, states)
for state, name in ipairs(states) do
if name == nodename then
return state
@ -128,23 +128,23 @@ function mesecon:getstate(nodename, states)
error(nodename.." doesn't mention itself in "..dump(states))
end
function mesecon:getbinstate(nodename, states)
return dec2bin(mesecon:getstate(nodename, states)-1)
function mesecon.getbinstate(nodename, states)
return dec2bin(mesecon.getstate(nodename, states)-1)
end
function mesecon:get_bit(binary,bit)
function mesecon.get_bit(binary,bit)
bit = bit or 1
local c = binary:len()-(bit-1)
return binary:sub(c,c) == "1"
end
function mesecon:set_bit(binary,bit,value)
function mesecon.set_bit(binary,bit,value)
if value == "1" then
if not mesecon:get_bit(binary,bit) then
if not mesecon.get_bit(binary,bit) then
return dec2bin(tonumber(binary,2)+math.pow(2,bit-1))
end
elseif value == "0" then
if mesecon:get_bit(binary,bit) then
if mesecon.get_bit(binary,bit) then
return dec2bin(tonumber(binary,2)-math.pow(2,bit-1))
end
end
@ -152,29 +152,29 @@ function mesecon:set_bit(binary,bit,value)
end
function mesecon:invertRule(r)
function mesecon.invertRule(r)
return {x = -r.x, y = -r.y, z = -r.z, sx = r.sx, sy = r.sy, sz = r.sz}
end
function mesecon:addPosRule(p, r)
function mesecon.addPosRule(p, r)
return {x = p.x + r.x, y = p.y + r.y, z = p.z + r.z}
end
function mesecon:cmpPos(p1, p2)
function mesecon.cmpPos(p1, p2)
return (p1.x == p2.x and p1.y == p2.y and p1.z == p2.z)
end
function mesecon:cmpSpecial(r1, r2)
function mesecon.cmpSpecial(r1, r2)
return (r1.sx == r2.sx and r1.sy == r2.sy and r1.sz == r2.sz)
end
function mesecon:tablecopy(table) -- deep table copy
function mesecon.tablecopy(table) -- deep table copy
if type(table) ~= "table" then return table end -- no need to copy
local newtable = {}
for idx, item in pairs(table) do
if type(item) == "table" then
newtable[idx] = mesecon:tablecopy(item)
newtable[idx] = mesecon.tablecopy(item)
else
newtable[idx] = item
end
@ -183,12 +183,12 @@ function mesecon:tablecopy(table) -- deep table copy
return newtable
end
function mesecon:cmpAny(t1, t2)
function mesecon.cmpAny(t1, t2)
if type(t1) ~= type(t2) then return false end
if type(t1) ~= "table" and type(t2) ~= "table" then return t1 == t2 end
for i, e in pairs(t1) do
if not mesecon:cmpAny(e, t2[i]) then return false end
if not mesecon.cmpAny(e, t2[i]) then return false end
end
return true

18
mesecons/wires.lua
View File

@ -18,12 +18,12 @@ local wire_getconnect = function (from_pos, self_pos)
if (minetest.registered_nodes[node.name].mesecon_wire) then
rules = mesecon.rules.default
else
rules = mesecon:get_any_inputrules(node) or {}
mesecon.mergetable(mesecon:get_any_outputrules(node) or {}, rules)
rules = mesecon.get_any_inputrules(node) or {}
mesecon.mergetable(mesecon.get_any_outputrules(node) or {}, rules)
end
for _, r in ipairs(mesecon:flattenrules(rules)) do
if (mesecon:cmpPos(mesecon:addPosRule(self_pos, r), from_pos)) then
for _, r in ipairs(mesecon.flattenrules(rules)) do
if (mesecon.cmpPos(mesecon.addPosRule(self_pos, r), from_pos)) then
return true
end
end
@ -36,7 +36,7 @@ local wire_updateconnect = function (pos)
local connections = {}
for _, r in ipairs(mesecon.rules.default) do
if wire_getconnect(pos, mesecon:addPosRule(pos, r)) then
if wire_getconnect(pos, mesecon.addPosRule(pos, r)) then
table.insert(connections, r)
end
end
@ -79,13 +79,13 @@ local update_on_place_dig = function (pos, node)
and minetest.registered_nodes[node.name].mesecon_wire then
rules = mesecon.rules.default
else
rules = mesecon:get_any_inputrules(node) or {}
mesecon.mergetable(mesecon:get_any_outputrules(node) or {}, rules)
rules = mesecon.get_any_inputrules(node) or {}
mesecon.mergetable(mesecon.get_any_outputrules(node) or {}, rules)
end
if (not rules) then return end
for _, r in ipairs(mesecon:flattenrules(rules)) do
local np = mesecon:addPosRule(pos, r)
for _, r in ipairs(mesecon.flattenrules(rules)) do
local np = mesecon.addPosRule(pos, r)
if minetest.registered_nodes[minetest.get_node(np).name]
and minetest.registered_nodes[minetest.get_node(np).name].mesecon_wire then
wire_updateconnect(np)

6
mesecons_blinkyplant/init.lua
View File

@ -64,7 +64,7 @@ minetest.register_node("mesecons_blinkyplant:blinky_plant_on", {
}},
on_rightclick = function(pos, node, clicker)
minetest.set_node(pos, {name = "mesecons_blinkyplant:blinky_plant"})
mesecon:receptor_off(pos)
mesecon.receptor_off(pos)
end
})
@ -87,10 +87,10 @@ minetest.register_abm({
action = function(pos, node, active_object_count, active_object_count_wider)
if node.name == "mesecons_blinkyplant:blinky_plant_off" then
minetest.add_node(pos, {name="mesecons_blinkyplant:blinky_plant_on"})
mesecon:receptor_on(pos)
mesecon.receptor_on(pos)
else
minetest.add_node(pos, {name="mesecons_blinkyplant:blinky_plant_off"})
mesecon:receptor_off(pos)
mesecon.receptor_off(pos)
end
nodeupdate(pos)
end,

4
mesecons_button/init.lua
View File

@ -8,7 +8,7 @@ mesecon.button_turnoff = function (pos)
minetest.swap_node(pos, {name = "mesecons_button:button_off", param2=node.param2})
minetest.sound_play("mesecons_button_pop", {pos=pos})
local rules = mesecon.rules.buttonlike_get(node)
mesecon:receptor_off(pos, rules)
mesecon.receptor_off(pos, rules)
end
end
@ -42,7 +42,7 @@ minetest.register_node("mesecons_button:button_off", {
description = "Button",
on_punch = function (pos, node)
minetest.swap_node(pos, {name = "mesecons_button:button_on", param2=node.param2})
mesecon:receptor_on(pos, mesecon.rules.buttonlike_get(node))
mesecon.receptor_on(pos, mesecon.rules.buttonlike_get(node))
minetest.sound_play("mesecons_button_push", {pos=pos})
minetest.after(1, mesecon.button_turnoff, pos)
end,

4
mesecons_delayer/init.lua
View File

@ -2,7 +2,7 @@
local delayer_get_output_rules = function(node)
local rules = {{x = 0, y = 0, z = 1}}
for i = 0, node.param2 do
rules = mesecon:rotate_rules_left(rules)
rules = mesecon.rotate_rules_left(rules)
end
return rules
end
@ -10,7 +10,7 @@ end
local delayer_get_input_rules = function(node)
local rules = {{x = 0, y = 0, z = -1}}
for i = 0, node.param2 do
rules = mesecon:rotate_rules_left(rules)
rules = mesecon.rotate_rules_left(rules)
end
return rules
end

8
mesecons_detector/init.lua
View File

@ -96,7 +96,7 @@ minetest.register_abm(
action = function(pos)
if object_detector_scan(pos) then
minetest.swap_node(pos, {name = "mesecons_detector:object_detector_on"})
mesecon:receptor_on(pos, mesecon.rules.pplate)
mesecon.receptor_on(pos, mesecon.rules.pplate)
end
end,
})
@ -108,7 +108,7 @@ minetest.register_abm(
action = function(pos)
if not object_detector_scan(pos) then
minetest.swap_node(pos, {name = "mesecons_detector:object_detector_off"})
mesecon:receptor_off(pos, mesecon.rules.pplate)
mesecon.receptor_off(pos, mesecon.rules.pplate)
end
end,
})
@ -250,7 +250,7 @@ minetest.register_abm(
action = function(pos, node)
if node_detector_scan(pos) then
minetest.swap_node(pos, {name = "mesecons_detector:node_detector_on", param2 = node.param2})
mesecon:receptor_on(pos)
mesecon.receptor_on(pos)
end
end,
})
@ -262,7 +262,7 @@ minetest.register_abm(
action = function(pos, node)
if not node_detector_scan(pos) then
minetest.swap_node(pos, {name = "mesecons_detector:node_detector_off", param2 = node.param2})
mesecon:receptor_off(pos)
mesecon.receptor_off(pos)
end
end,
})

2
mesecons_extrawires/corner.lua
View File

@ -15,7 +15,7 @@ local corner_get_rules = function (node)
{x = 0, y = 0, z = -1}}
for i = 0, node.param2 do
rules = mesecon:rotate_rules_left(rules)
rules = mesecon.rotate_rules_left(rules)
end
return rules

2
mesecons_extrawires/tjunction.lua
View File

@ -16,7 +16,7 @@ local tjunction_get_rules = function (node)
{x = 0, y = 0, z = -1}}
for i = 0, node.param2 do
rules = mesecon:rotate_rules_left(rules)
rules = mesecon.rotate_rules_left(rules)
end
return rules

8
mesecons_extrawires/vertical.lua
View File

@ -42,8 +42,8 @@ local vertical_updatepos = function (pos)
local node = minetest.get_node(pos)
if minetest.registered_nodes[node.name]
and minetest.registered_nodes[node.name].is_vertical_conductor then
local node_above = minetest.get_node(mesecon:addPosRule(pos, vertical_rules[1]))
local node_below = minetest.get_node(mesecon:addPosRule(pos, vertical_rules[2]))
local node_above = minetest.get_node(mesecon.addPosRule(pos, vertical_rules[1]))
local node_below = minetest.get_node(mesecon.addPosRule(pos, vertical_rules[2]))
local namestate = minetest.registered_nodes[node.name].vertical_conductor_state
local above = minetest.registered_nodes[node_above.name]
@ -66,8 +66,8 @@ end
local vertical_update = function (pos, node)
vertical_updatepos(pos) -- this one
vertical_updatepos(mesecon:addPosRule(pos, vertical_rules[1])) -- above
vertical_updatepos(mesecon:addPosRule(pos, vertical_rules[2])) -- below
vertical_updatepos(mesecon.addPosRule(pos, vertical_rules[1])) -- above
vertical_updatepos(mesecon.addPosRule(pos, vertical_rules[2])) -- below
end
-- Vertical wire

8
mesecons_gates/init.lua
View File

@ -1,6 +1,6 @@
function gate_rotate_rules(node)
for rotations = 0, node.param2 - 1 do
rules = mesecon:rotate_rules_left(rules)
rules = mesecon.rotate_rules_left(rules)
end
return rules
end
@ -53,11 +53,11 @@ function set_gate(pos, on)
local node = minetest.get_node(pos)
if on then
minetest.swap_node(pos, {name = "mesecons_gates:"..gate.."_on", param2=node.param2})
mesecon:receptor_on(pos,
mesecon.receptor_on(pos,
gate_get_output_rules(node))
else
minetest.swap_node(pos, {name = "mesecons_gates:"..gate.."_off", param2=node.param2})
mesecon:receptor_off(pos,
mesecon.receptor_off(pos,
gate_get_output_rules(node))
end
end
@ -77,7 +77,7 @@ function pop_gate(pos)
gate = get_gate(pos)
minetest.remove_node(pos)
minetest.after(0.2, function (pos)
mesecon:receptor_off(pos, mesecon.rules.flat)
mesecon.receptor_off(pos, mesecon.rules.flat)
end , pos) -- wait for pending parsings
minetest.add_item(pos, "mesecons_gates:"..gate.."_off")
end

4
mesecons_hydroturbine/init.lua
View File

@ -66,7 +66,7 @@ nodenames = {"mesecons_hydroturbine:hydro_turbine_off"},
if minetest.get_node(waterpos).name=="default:water_flowing" then
minetest.add_node(pos, {name="mesecons_hydroturbine:hydro_turbine_on"})
nodeupdate(pos)
mesecon:receptor_on(pos)
mesecon.receptor_on(pos)
end
end,
})
@ -80,7 +80,7 @@ nodenames = {"mesecons_hydroturbine:hydro_turbine_on"},
if minetest.get_node(waterpos).name~="default:water_flowing" then
minetest.add_node(pos, {name="mesecons_hydroturbine:hydro_turbine_off"})
nodeupdate(pos)
mesecon:receptor_off(pos)
mesecon.receptor_off(pos)
end
end,
})

2
mesecons_insulated/init.lua
View File

@ -2,7 +2,7 @@ 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)
return mesecon.rotate_rules_right(rules)
end
return rules
end

14
mesecons_lightstone/init.lua
View File

@ -14,7 +14,7 @@ local lightstone_rules = {
{x=0, y=-1, z=0},
}
function mesecon:lightstone_add(name, base_item, texture_off, texture_on)
function mesecon.lightstone_add(name, base_item, texture_off, texture_on)
minetest.register_node("mesecons_lightstone:lightstone_" .. name .. "_off", {
tiles = {texture_off},
groups = {cracky=2, mesecon_effector_off = 1, mesecon = 2},
@ -52,9 +52,9 @@ function mesecon:lightstone_add(name, base_item, texture_off, texture_on)
end
mesecon:lightstone_add("red", "default:clay_brick", "jeija_lightstone_red_off.png", "jeija_lightstone_red_on.png")
mesecon:lightstone_add("green", "default:cactus", "jeija_lightstone_green_off.png", "jeija_lightstone_green_on.png")
mesecon:lightstone_add("blue", "mesecons_materials:fiber", "jeija_lightstone_blue_off.png", "jeija_lightstone_blue_on.png")
mesecon:lightstone_add("gray", "default:cobble", "jeija_lightstone_gray_off.png", "jeija_lightstone_gray_on.png")
mesecon:lightstone_add("darkgray", "default:gravel", "jeija_lightstone_darkgray_off.png", "jeija_lightstone_darkgray_on.png")
mesecon:lightstone_add("yellow", "default:mese_crystal_fragment", "jeija_lightstone_yellow_off.png", "jeija_lightstone_yellow_on.png")
mesecon.lightstone_add("red", "default:clay_brick", "jeija_lightstone_red_off.png", "jeija_lightstone_red_on.png")
mesecon.lightstone_add("green", "default:cactus", "jeija_lightstone_green_off.png", "jeija_lightstone_green_on.png")
mesecon.lightstone_add("blue", "mesecons_materials:fiber", "jeija_lightstone_blue_off.png", "jeija_lightstone_blue_on.png")
mesecon.lightstone_add("gray", "default:cobble", "jeija_lightstone_gray_off.png", "jeija_lightstone_gray_on.png")
mesecon.lightstone_add("darkgray", "default:gravel", "jeija_lightstone_darkgray_off.png", "jeija_lightstone_darkgray_on.png")
mesecon.lightstone_add("yellow", "default:mese_crystal_fragment", "jeija_lightstone_yellow_off.png", "jeija_lightstone_yellow_on.png")

15
mesecons_luacontroller/init.lua
View File

@ -38,10 +38,6 @@ function lc_update_real_portstates(pos, rulename, newstate)
return
end
local n = meta:get_int("real_portstates") - 1
if n < 0 then
legacy_update_ports(pos)
n = meta:get_int("real_portstates") - 1
end
local L = {}
for i = 1, 4 do
L[i] = n%2
@ -63,9 +59,6 @@ local get_real_portstates = function(pos) -- determine if ports are powered (by
local meta = minetest.get_meta(pos)
local L = {}
local n = meta:get_int("real_portstates") - 1
if n < 0 then
return legacy_update_ports(pos)
end
for _, index in ipairs({"a", "b", "c", "d"}) do
L[index] = ((n%2) == 1)
n = math.floor(n/2)
@ -92,9 +85,9 @@ end
local setport = function (pos, rule, state)
if state then
mesecon:receptor_on(pos, {rule})
mesecon.receptor_on(pos, {rule})
else
mesecon:receptor_off(pos, {rule})
mesecon.receptor_off(pos, {rule})
end
end
@ -122,7 +115,7 @@ end
--------------------
local overheat_off = function(pos)
mesecon:receptor_off(pos, mesecon.rules.flat)
mesecon.receptor_off(pos, mesecon.rules.flat)
end
-------------------
@ -484,7 +477,7 @@ minetest.register_node(nodename, {
c = c == 1, -- controller powers itself
d = d == 1},-- so those that light up
after_dig_node = function (pos, node)
mesecon:receptor_off(pos, output_rules)
mesecon.receptor_off(pos, output_rules)
end,
is_luacontroller = true,
})

68
mesecons_microcontroller/init.lua
View File

@ -134,7 +134,7 @@ minetest.register_node(nodename, {
mesecons = mesecons,
after_dig_node = function (pos, node)
rules = microc_rules[node.name]
mesecon:receptor_off(pos, rules)
mesecon.receptor_off(pos, rules)
end,
})
end
@ -166,7 +166,7 @@ function update_yc(pos)
if (mesecon.do_overheat(pos)) then
minetest.remove_node(pos)
minetest.after(0.2, function (pos)
mesecon:receptor_off(pos, mesecon.rules.flat)
mesecon.receptor_off(pos, mesecon.rules.flat)
end , pos) -- wait for pending parsings
minetest.add_item(pos, "mesecons_microcontroller:microcontroller0000")
end
@ -185,7 +185,7 @@ end
--Code Parsing
function yc_code_remove_commentary(code)
is_string = false
local is_string = false
for i = 1, #code do
if code:sub(i, i) == '"' then
is_string = not is_string --toggle is_string
@ -205,15 +205,17 @@ function yc_parsecode(code, pos)
local c
local eeprom = meta:get_string("eeprom")
while true do
local command, params
command, endi = parse_get_command(code, endi)
if command == nil then return nil end
if command == true then break end --end of code
if command == "if" then
local r
r, endi = yc_command_if(code, endi, yc_merge_portstates(Lreal, Lvirtual), eeprom)
if r == nil then return nil end
if r == true then -- nothing
elseif r == false then
endi_new = yc_skip_to_else (code, endi)
local endi_new = yc_skip_to_else (code, endi)
if endi_new == nil then --else > not found
endi = yc_skip_to_endif(code, endi)
else
@ -223,7 +225,7 @@ function yc_parsecode(code, pos)
end
else
params, endi = parse_get_params(code, endi)
if params == nil then return nil end
if not params then return nil end
end
if command == "on" then
L = yc_command_on (params, Lvirtual)
@ -236,6 +238,7 @@ function yc_parsecode(code, pos)
local su = yc_command_after(params, pos)
if su == nil then return nil end
elseif command == "sbi" then
local new_eeprom
new_eeprom, Lvirtual = yc_command_sbi (params, eeprom, yc_merge_portstates(Lreal, Lvirtual), Lvirtual)
if new_eeprom == nil then return nil
else eeprom = new_eeprom end
@ -253,7 +256,7 @@ end
function parse_get_command(code, starti)
i = starti
s = nil
local s
while s ~= "" do
s = string.sub(code, i, i)
if s == "(" then
@ -279,7 +282,7 @@ end
function parse_get_params(code, starti)
i = starti
s = nil
local s
local params = {}
local is_string = false
while s ~= "" do
@ -302,7 +305,7 @@ end
function yc_parse_get_eeprom_param(cond, starti)
i = starti
s = nil
local s
local addr
while s ~= "" do
s = string.sub(cond, i, i)
@ -405,7 +408,7 @@ function yc_command_sbi(params, eeprom, L, Lv)
end
--is an eeprom address
new_eeprom = "";
local new_eeprom = "";
for i=1, #eeprom do
if tonumber(params[1])==i then
new_eeprom = new_eeprom..status
@ -459,17 +462,17 @@ function yc_command_if(code, starti, L, eeprom)
cond = yc_command_parsecondition(cond, L, eeprom)
local result
if cond == "0" then result = false
elseif cond == "1" then result = true
else result = nil end
if result == nil then end
elseif cond == "1" then result = true end
if not result then end
return result, endi --endi from local cond, endi = yc_command_if_getcondition(code, starti)
end
--Condition parsing
function yc_command_if_getcondition(code, starti)
i = starti
s = nil
local s
local brackets = 1 --1 Bracket to close
while s ~= "" do
s = string.sub(code, i, i)
@ -503,8 +506,8 @@ function yc_command_parsecondition(cond, L, eeprom)
while i<=l do
local s = cond:sub(i,i)
if s == "#" then
addr, endi = yc_parse_get_eeprom_param(cond, i+1)
buf = yc_eeprom_read(tonumber(addr), eeprom)
local addr, endi = yc_parse_get_eeprom_param(cond, i+1)
local buf = yc_eeprom_read(tonumber(addr), eeprom)
if buf == nil then return nil end
local call = cond:sub(i, endi-1)
cond = string.gsub(cond, call, buf)
@ -578,10 +581,8 @@ end
--Virtual-Hardware functions
function yc_eeprom_read(number, eeprom)
if number == nil then return nil, nil end
value = eeprom:sub(number, number)
if value == nil then return nil, nil end
return value, endi
if not number then return end
return eeprom:sub(number, number)
end
--Real I/O functions
@ -603,23 +604,23 @@ function yc_action_setports(pos, L, Lv)
local rules
if Lv.a ~= L.a then
rules = microc_rules[name.."0001"]
if L.a == true then mesecon:receptor_on(pos, rules)
else mesecon:receptor_off(pos, rules) end
if L.a == true then mesecon.receptor_on(pos, rules)
else mesecon.receptor_off(pos, rules) end
end
if Lv.b ~= L.b then
rules = microc_rules[name.."0010"]
if L.b == true then mesecon:receptor_on(pos, rules)
else mesecon:receptor_off(pos, rules) end
if L.b == true then mesecon.receptor_on(pos, rules)
else mesecon.receptor_off(pos, rules) end
end
if Lv.c ~= L.c then
rules = microc_rules[name.."0100"]
if L.c == true then mesecon:receptor_on(pos, rules)
else mesecon:receptor_off(pos, rules) end
if L.c == true then mesecon.receptor_on(pos, rules)
else mesecon.receptor_off(pos, rules) end
end
if Lv.d ~= L.d then
rules = microc_rules[name.."1000"]
if L.d == true then mesecon:receptor_on(pos, rules)
else mesecon:receptor_off(pos, rules) end
if L.d == true then mesecon.receptor_on(pos, rules)
else mesecon.receptor_off(pos, rules) end
end
end
@ -639,10 +640,6 @@ function yc_update_real_portstates(pos, node, rulename, newstate)
return
end
local n = meta:get_int("real_portstates") - 1
if n < 0 then
legacy_update_ports(pos)
n = meta:get_int("real_portstates") - 1
end
local L = {}
for i = 1, 4 do
L[i] = n%2
@ -664,9 +661,6 @@ function yc_get_real_portstates(pos) -- determine if ports are powered (by itsel
local meta = minetest.get_meta(pos)
local L = {}
local n = meta:get_int("real_portstates") - 1
if n < 0 then
return legacy_update_ports(pos)
end
for _, index in ipairs({"a", "b", "c", "d"}) do
L[index] = ((n%2) == 1)
n = math.floor(n/2)
@ -675,12 +669,12 @@ function yc_get_real_portstates(pos) -- determine if ports are powered (by itsel
end
function yc_get_virtual_portstates(pos) -- portstates according to the name
name = minetest.get_node(pos).name
b, a = string.find(name, ":microcontroller")
local name = minetest.get_node(pos).name
local b, a = string.find(name, ":microcontroller")
if a == nil then return nil end
a = a + 1
Lvirtual = {a=false, b=false, c=false, d=false}
local Lvirtual = {a=false, b=false, c=false, d=false}
if name:sub(a , a ) == "1" then Lvirtual.d = true end
if name:sub(a+1, a+1) == "1" then Lvirtual.c = true end
if name:sub(a+2, a+2) == "1" then Lvirtual.b = true end

42
mesecons_movestones/init.lua
View File

@ -8,7 +8,7 @@
-- Pushes all block in front of it
-- Pull all blocks in its back
function mesecon:get_movestone_direction(pos)
function mesecon.get_movestone_direction(pos)
getactivated = 0
local lpos
local getactivated = 0
@ -28,28 +28,28 @@ function mesecon:get_movestone_direction(pos)
lpos = {x=pos.x+1, y=pos.y, z=pos.z}
for n = 1, 3 do
if mesecon:is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
if mesecon.is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
return {x=0, y=0, z=-1}
end
end
lpos = {x = pos.x-1, y = pos.y, z = pos.z}
for n=4, 6 do
if mesecon:is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
if mesecon.is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
return {x=0, y=0, z=1}
end
end
lpos = {x = pos.x, y = pos.y, z = pos.z+1}
for n=7, 9 do
if mesecon:is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
if mesecon.is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
return {x=-1, y=0, z=0}
end
end
lpos = {x = pos.x, y = pos.y, z = pos.z-1}
for n=10, 12 do
if mesecon:is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
if mesecon.is_power_on(lpos, rules[n].x, rules[n].y, rules[n].z) then
return {x=1, y=0, z=0}
end
end
@ -64,7 +64,7 @@ minetest.register_node("mesecons_movestones:movestone", {
sounds = default.node_sound_stone_defaults(),
mesecons = {effector = {
action_on = function (pos, node)
local direction=mesecon:get_movestone_direction(pos)
local direction=mesecon.get_movestone_direction(pos)
if not direction then return end
minetest.remove_node(pos)
mesecon.update_autoconnect(pos)
@ -89,7 +89,7 @@ minetest.register_entity("mesecons_movestones:movestone_entity", {
on_step = function(self, dtime)
local pos = self.object:getpos()
pos.x, pos.y, pos.z = math.floor(pos.x+0.5), math.floor(pos.y+0.5), math.floor(pos.z+0.5)
local direction = mesecon:get_movestone_direction(pos)
local direction = mesecon.get_movestone_direction(pos)
if not direction then -- no mesecon power
--push only solid nodes
@ -97,7 +97,7 @@ minetest.register_entity("mesecons_movestones:movestone_entity", {
if name ~= "air" and name ~= "ignore"
and ((not minetest.registered_nodes[name])
or minetest.registered_nodes[name].liquidtype == "none") then
mesecon:mvps_push(pos, self.lastdir, MOVESTONE_MAXIMUM_PUSH)
mesecon.mvps_push(pos, self.lastdir, MOVESTONE_MAXIMUM_PUSH)
end
minetest.add_node(pos, {name="mesecons_movestones:movestone"})
self.object:remove()
@ -105,14 +105,14 @@ minetest.register_entity("mesecons_movestones:movestone_entity", {
end
local success, stack, oldstack =
mesecon:mvps_push(pos, direction, MOVESTONE_MAXIMUM_PUSH)
mesecon.mvps_push(pos, direction, MOVESTONE_MAXIMUM_PUSH)
if not success then -- Too large stack/stopper in the way
minetest.add_node(pos, {name="mesecons_movestones:movestone"})
self.object:remove()
return
else
mesecon:mvps_process_stack (stack)
mesecon:mvps_move_objects (pos, direction, oldstack)
mesecon.mvps_process_stack (stack)
mesecon.mvps_move_objects (pos, direction, oldstack)
self.lastdir = direction
end
@ -143,7 +143,7 @@ minetest.register_node("mesecons_movestones:sticky_movestone", {
sounds = default.node_sound_stone_defaults(),
mesecons = {effector = {
action_on = function (pos, node)
local direction=mesecon:get_movestone_direction(pos)
local direction=mesecon.get_movestone_direction(pos)
if not direction then return end
minetest.remove_node(pos)
mesecon.update_autoconnect(pos)
@ -175,7 +175,7 @@ minetest.register_entity("mesecons_movestones:sticky_movestone_entity", {
on_step = function(self, dtime)
local pos = self.object:getpos()
pos.x, pos.y, pos.z = math.floor(pos.x+0.5), math.floor(pos.y+0.5), math.floor(pos.z+0.5)
local direction = mesecon:get_movestone_direction(pos)
local direction = mesecon.get_movestone_direction(pos)
if not direction then -- no mesecon power
--push only solid nodes
@ -183,9 +183,9 @@ minetest.register_entity("mesecons_movestones:sticky_movestone_entity", {
if name ~= "air" and name ~= "ignore"
and ((not minetest.registered_nodes[name])
or minetest.registered_nodes[name].liquidtype == "none") then
mesecon:mvps_push(pos, self.lastdir, MOVESTONE_MAXIMUM_PUSH)
mesecon.mvps_push(pos, self.lastdir, MOVESTONE_MAXIMUM_PUSH)
--STICKY
mesecon:mvps_pull_all(pos, self.lastdir)
mesecon.mvps_pull_all(pos, self.lastdir)
end
minetest.add_node(pos, {name="mesecons_movestones:sticky_movestone"})
self.object:remove()
@ -193,24 +193,24 @@ minetest.register_entity("mesecons_movestones:sticky_movestone_entity", {
end
local success, stack, oldstack =
mesecon:mvps_push(pos, direction, MOVESTONE_MAXIMUM_PUSH)
mesecon.mvps_push(pos, direction, MOVESTONE_MAXIMUM_PUSH)
if not success then -- Too large stack/stopper in the way
minetest.add_node(pos, {name="mesecons_movestones:sticky_movestone"})
self.object:remove()
return
else
mesecon:mvps_process_stack (stack)
mesecon:mvps_move_objects (pos, direction, oldstack)
mesecon.mvps_process_stack (stack)
mesecon.mvps_move_objects (pos, direction, oldstack)
self.lastdir = direction
end
self.object:setvelocity({x=direction.x*2, y=direction.y*2, z=direction.z*2})
--STICKY
mesecon:mvps_pull_all(pos, direction)
mesecon.mvps_pull_all(pos, direction)
end,
})
mesecon:register_mvps_unmov("mesecons_movestones:movestone_entity")
mesecon:register_mvps_unmov("mesecons_movestones:sticky_movestone_entity")
mesecon.register_mvps_unmov("mesecons_movestones:movestone_entity")
mesecon.register_mvps_unmov("mesecons_movestones:sticky_movestone_entity")

52
mesecons_mvps/init.lua
View File

@ -4,7 +4,7 @@ mesecon.mvps_stoppers = {}
mesecon.mvps_unmov = {}
mesecon.on_mvps_move = {}
function mesecon:is_mvps_stopper(node, pushdir, stack, stackid)
function mesecon.is_mvps_stopper(node, pushdir, stack, stackid)
local get_stopper = mesecon.mvps_stoppers[node.name]
if type (get_stopper) == "function" then
get_stopper = get_stopper(node, pushdir, stack, stackid)
@ -12,7 +12,7 @@ function mesecon:is_mvps_stopper(node, pushdir, stack, stackid)
return get_stopper
end
function mesecon:register_mvps_stopper(nodename, get_stopper)
function mesecon.register_mvps_stopper(nodename, get_stopper)
if get_stopper == nil then
get_stopper = true
end
@ -20,16 +20,16 @@ function mesecon:register_mvps_stopper(nodename, get_stopper)
end
-- Objects that cannot be moved (e.g. movestones)
function mesecon:register_mvps_unmov(objectname)
function mesecon.register_mvps_unmov(objectname)
mesecon.mvps_unmov[objectname] = true;
end
function mesecon:is_mvps_unmov(objectname)
function mesecon.is_mvps_unmov(objectname)
return mesecon.mvps_unmov[objectname]
end
-- Functions to be called on mvps movement
function mesecon:register_on_mvps_move(callback)
function mesecon.register_on_mvps_move(callback)
mesecon.on_mvps_move[#mesecon.on_mvps_move+1] = callback
end
@ -39,14 +39,14 @@ local function on_mvps_move(moved_nodes)
end
end
function mesecon:mvps_process_stack(stack)
function mesecon.mvps_process_stack(stack)
-- update mesecons for placed nodes ( has to be done after all nodes have been added )
for _, n in ipairs(stack) do
mesecon.on_placenode(n.pos, minetest.get_node(n.pos))
end
end
function mesecon:mvps_get_stack(pos, dir, maximum)
function mesecon.mvps_get_stack(pos, dir, maximum)
-- determine the number of nodes to be pushed
local np = {x = pos.x, y = pos.y, z = pos.z}
local nodes = {}
@ -65,18 +65,18 @@ function mesecon:mvps_get_stack(pos, dir, maximum)
table.insert (nodes, {node = nn, pos = np})
np = mesecon:addPosRule(np, dir)
np = mesecon.addPosRule(np, dir)
end
return nodes
end
function mesecon:mvps_push(pos, dir, maximum) -- pos: pos of mvps; dir: direction of push; maximum: maximum nodes to be pushed
local nodes = mesecon:mvps_get_stack(pos, dir, maximum)
function mesecon.mvps_push(pos, dir, maximum) -- pos: pos of mvps; dir: direction of push; maximum: maximum nodes to be pushed
local nodes = mesecon.mvps_get_stack(pos, dir, maximum)
if not nodes then return end
-- determine if one of the nodes blocks the push
for id, n in ipairs(nodes) do
if mesecon:is_mvps_stopper(n.node, dir, nodes, id) then
if mesecon.is_mvps_stopper(n.node, dir, nodes, id) then
return
end
end
@ -94,17 +94,17 @@ function mesecon:mvps_push(pos, dir, maximum) -- pos: pos of mvps; dir: directio
-- add nodes
for _, n in ipairs(nodes) do
np = mesecon:addPosRule(n.pos, dir)
np = mesecon.addPosRule(n.pos, dir)
minetest.add_node(np, n.node)
minetest.get_meta(np):from_table(n.meta)
end
local moved_nodes = {}
local oldstack = mesecon:tablecopy(nodes)
local oldstack = mesecon.tablecopy(nodes)
for i in ipairs(nodes) do
moved_nodes[i] = {}
moved_nodes[i].oldpos = nodes[i].pos
nodes[i].pos = mesecon:addPosRule(nodes[i].pos, dir)
nodes[i].pos = mesecon.addPosRule(nodes[i].pos, dir)
moved_nodes[i].pos = nodes[i].pos
moved_nodes[i].node = nodes[i].node
moved_nodes[i].meta = nodes[i].meta
@ -115,20 +115,20 @@ function mesecon:mvps_push(pos, dir, maximum) -- pos: pos of mvps; dir: directio
return true, nodes, oldstack
end
mesecon:register_on_mvps_move(function(moved_nodes)
mesecon.register_on_mvps_move(function(moved_nodes)
for _, n in ipairs(moved_nodes) do
mesecon.on_placenode(n.pos, n.node)
mesecon.update_autoconnect(n.pos)
end
end)
function mesecon:mvps_pull_single(pos, dir) -- pos: pos of mvps; direction: direction of pull (matches push direction for sticky pistons)
np = mesecon:addPosRule(pos, dir)
function mesecon.mvps_pull_single(pos, dir) -- pos: pos of mvps; direction: direction of pull (matches push direction for sticky pistons)
np = mesecon.addPosRule(pos, dir)
nn = minetest.get_node(np)
if ((not minetest.registered_nodes[nn.name]) --unregistered node
or minetest.registered_nodes[nn.name].liquidtype == "none") --non-liquid node
and not mesecon:is_mvps_stopper(nn, {x = -dir.x, y = -dir.y, z = -dir.z}, {{pos = np, node = nn}}, 1) then --non-stopper node
and not mesecon.is_mvps_stopper(nn, {x = -dir.x, y = -dir.y, z = -dir.z}, {{pos = np, node = nn}}, 1) then --non-stopper node
local meta = minetest.get_meta(np):to_table()
minetest.remove_node(np)
minetest.add_node(pos, nn)
@ -143,7 +143,7 @@ function mesecon:mvps_pull_single(pos, dir) -- pos: pos of mvps; direction: dire
return {{pos = np, node = {param2 = 0, name = "air"}}, {pos = pos, node = nn}}
end
function mesecon:mvps_pull_all(pos, direction) -- pos: pos of mvps; direction: direction of pull
function mesecon.mvps_pull_all(pos, direction) -- pos: pos of mvps; direction: direction of pull
local lpos = {x=pos.x-direction.x, y=pos.y-direction.y, z=pos.z-direction.z} -- 1 away
local lnode = minetest.get_node(lpos)
local lpos2 = {x=pos.x-direction.x*2, y=pos.y-direction.y*2, z=pos.z-direction.z*2} -- 2 away
@ -189,11 +189,11 @@ function mesecon:mvps_pull_all(pos, direction) -- pos: pos of mvps; direction: d
on_mvps_move(moved_nodes)
end
function mesecon:mvps_move_objects(pos, dir, nodestack)
function mesecon.mvps_move_objects(pos, dir, nodestack)
local objects_to_move = {}
-- Move object at tip of stack
local pushpos = mesecon:addPosRule(pos, -- get pos at tip of stack
local pushpos = mesecon.addPosRule(pos, -- get pos at tip of stack
{x = dir.x * #nodestack,
y = dir.y * #nodestack,
z = dir.z * #nodestack})
@ -208,7 +208,7 @@ function mesecon:mvps_move_objects(pos, dir, nodestack)
if tonumber(minetest.setting_get("movement_gravity")) > 0 and dir.y == 0 then
-- If gravity positive and dir horizontal, push players standing on the stack
for _, n in ipairs(nodestack) do
local p_above = mesecon:addPosRule(n.pos, {x=0, y=1, z=0})
local p_above = mesecon.addPosRule(n.pos, {x=0, y=1, z=0})
local objects = minetest.get_objects_inside_radius(p_above, 1)
for _, obj in ipairs(objects) do
table.insert(objects_to_move, obj)
@ -218,8 +218,8 @@ function mesecon:mvps_move_objects(pos, dir, nodestack)
for _, obj in ipairs(objects_to_move) do
local entity = obj:get_luaentity()
if not entity or not mesecon:is_mvps_unmov(entity.name) then
local np = mesecon:addPosRule(obj:getpos(), dir)
if not entity or not mesecon.is_mvps_unmov(entity.name) then
local np = mesecon.addPosRule(obj:getpos(), dir)
--move only if destination is not solid
local nn = minetest.get_node(np)
@ -231,5 +231,5 @@ function mesecon:mvps_move_objects(pos, dir, nodestack)
end
end
mesecon:register_mvps_stopper("default:chest_locked")
mesecon:register_mvps_stopper("default:furnace")
mesecon.register_mvps_stopper("default:chest_locked")
mesecon.register_mvps_stopper("default:furnace")

48
mesecons_pistons/init.lua
View File

@ -33,7 +33,7 @@ local piston_down_rules =
local piston_get_rules = function (node)
local rules = piston_rules
for i = 1, node.param2 do
rules = mesecon:rotate_rules_left(rules)
rules = mesecon.rotate_rules_left(rules)
end
return rules
end
@ -41,7 +41,7 @@ end
piston_facedir_direction = function (node)
local rules = {{x = 0, y = 0, z = -1}}
for i = 1, node.param2 do
rules = mesecon:rotate_rules_left(rules)
rules = mesecon.rotate_rules_left(rules)
end
return rules[1]
end
@ -57,7 +57,7 @@ end
local piston_remove_pusher = function(pos, node)
pistonspec = minetest.registered_nodes[node.name].mesecons_piston
dir = piston_get_direction(pistonspec.dir, node)
local pusherpos = mesecon:addPosRule(pos, dir)
local pusherpos = mesecon.addPosRule(pos, dir)
local pushername = minetest.get_node(pusherpos).name
-- make sure there actually is a pusher (for compatibility reasons mainly)
@ -78,8 +78,8 @@ local piston_on = function(pos, node)
local pistonspec = minetest.registered_nodes[node.name].mesecons_piston
local dir = piston_get_direction(pistonspec.dir, node)
local np = mesecon:addPosRule(pos, dir)
local success, stack, oldstack = mesecon:mvps_push(np, dir, PISTON_MAXIMUM_PUSH)
local np = mesecon.addPosRule(pos, dir)
local success, stack, oldstack = mesecon.mvps_push(np, dir, PISTON_MAXIMUM_PUSH)
if success then
minetest.add_node(pos, {param2 = node.param2, name = pistonspec.onname})
minetest.add_node(np, {param2 = node.param2, name = pistonspec.pusher})
@ -88,8 +88,8 @@ local piston_on = function(pos, node)
max_hear_distance = 20,
gain = 0.3,
})
mesecon:mvps_process_stack (stack)
mesecon:mvps_move_objects (np, dir, oldstack)
mesecon.mvps_process_stack (stack)
mesecon.mvps_move_objects (np, dir, oldstack)
end
end
@ -100,9 +100,9 @@ local piston_off = function(pos, node)
if pistonspec.sticky then
dir = piston_get_direction(pistonspec.dir, node)
pullpos = mesecon:addPosRule(pos, dir)
stack = mesecon:mvps_pull_single(pullpos, dir)
mesecon:mvps_process_stack(pos, dir, stack)
pullpos = mesecon.addPosRule(pos, dir)
stack = mesecon.mvps_pull_single(pullpos, dir)
mesecon.mvps_process_stack(pos, dir, stack)
end
end
@ -693,14 +693,14 @@ local piston_pusher_up_down_get_stopper = function (node, dir, stack, stackid)
return true
end
mesecon:register_mvps_stopper("mesecons_pistons:piston_pusher_normal", piston_pusher_get_stopper)
mesecon:register_mvps_stopper("mesecons_pistons:piston_pusher_sticky", piston_pusher_get_stopper)
mesecon.register_mvps_stopper("mesecons_pistons:piston_pusher_normal", piston_pusher_get_stopper)
mesecon.register_mvps_stopper("mesecons_pistons:piston_pusher_sticky", piston_pusher_get_stopper)
mesecon:register_mvps_stopper("mesecons_pistons:piston_up_pusher_normal", piston_pusher_up_down_get_stopper)
mesecon:register_mvps_stopper("mesecons_pistons:piston_up_pusher_sticky", piston_pusher_up_down_get_stopper)
mesecon.register_mvps_stopper("mesecons_pistons:piston_up_pusher_normal", piston_pusher_up_down_get_stopper)
mesecon.register_mvps_stopper("mesecons_pistons:piston_up_pusher_sticky", piston_pusher_up_down_get_stopper)
mesecon:register_mvps_stopper("mesecons_pistons:piston_down_pusher_normal", piston_pusher_up_down_get_stopper)
mesecon:register_mvps_stopper("mesecons_pistons:piston_down_pusher_sticky", piston_pusher_up_down_get_stopper)
mesecon.register_mvps_stopper("mesecons_pistons:piston_down_pusher_normal", piston_pusher_up_down_get_stopper)
mesecon.register_mvps_stopper("mesecons_pistons:piston_down_pusher_sticky", piston_pusher_up_down_get_stopper)
-- Register pistons as stoppers if they would be seperated from the stopper
@ -717,12 +717,12 @@ end
local piston_get_stopper = function (node, dir, stack, stackid)
pistonspec = minetest.registered_nodes[node.name].mesecons_piston
dir = piston_get_direction(pistonspec.dir, node)
local pusherpos = mesecon:addPosRule(stack[stackid].pos, dir)
local pusherpos = mesecon.addPosRule(stack[stackid].pos, dir)
local pushernode = minetest.get_node(pusherpos)
if minetest.registered_nodes[node.name].mesecons_piston.pusher == pushernode.name then
for _, s in ipairs(stack) do
if mesecon:cmpPos(s.pos, pusherpos) -- pusher is also to be pushed
if mesecon.cmpPos(s.pos, pusherpos) -- pusher is also to be pushed
and s.node.param2 == node.param2 then
return false
end
@ -731,14 +731,14 @@ local piston_get_stopper = function (node, dir, stack, stackid)
return true
end
mesecon:register_mvps_stopper("mesecons_pistons:piston_normal_on", piston_get_stopper)
mesecon:register_mvps_stopper("mesecons_pistons:piston_sticky_on", piston_get_stopper)
mesecon.register_mvps_stopper("mesecons_pistons:piston_normal_on", piston_get_stopper)
mesecon.register_mvps_stopper("mesecons_pistons:piston_sticky_on", piston_get_stopper)
mesecon:register_mvps_stopper("mesecons_pistons:piston_up_normal_on", piston_up_down_get_stopper)
mesecon:register_mvps_stopper("mesecons_pistons:piston_up_sticky_on", piston_up_down_get_stopper)
mesecon.register_mvps_stopper("mesecons_pistons:piston_up_normal_on", piston_up_down_get_stopper)
mesecon.register_mvps_stopper("mesecons_pistons:piston_up_sticky_on", piston_up_down_get_stopper)
mesecon:register_mvps_stopper("mesecons_pistons:piston_down_normal_on", piston_up_down_get_stopper)
mesecon:register_mvps_stopper("mesecons_pistons:piston_down_sticky_on", piston_up_down_get_stopper)
mesecon.register_mvps_stopper("mesecons_pistons:piston_down_normal_on", piston_up_down_get_stopper)
mesecon.register_mvps_stopper("mesecons_pistons:piston_down_sticky_on", piston_up_down_get_stopper)
--craft recipes
minetest.register_craft({

18
mesecons_pressureplates/init.lua
View File

@ -17,23 +17,23 @@ pp_on_timer = function (pos, elapsed)
if not basename then return end
local objs = minetest.get_objects_inside_radius(pos, 1)
local two_below = mesecon:addPosRule(pos, {x = 0, y = -2, z = 0})
local two_below = mesecon.addPosRule(pos, {x = 0, y = -2, z = 0})
if objs[1] == nil and node.name == basename .. "_on" then
minetest.add_node(pos, {name = basename .. "_off"})
mesecon:receptor_off(pos, mesecon.rules.pplate)
mesecon.receptor_off(pos, mesecon.rules.pplate)
-- force deactivation of mesecon two blocks below (hacky)
if not mesecon:connected_to_receptor(two_below) then
mesecon:turnoff(two_below)
if not mesecon.connected_to_receptor(two_below) then
mesecon.turnoff(two_below)
end
else
for k, obj in pairs(objs) do
local objpos = obj:getpos()
if objpos.y > pos.y-1 and objpos.y < pos.y then
minetest.add_node(pos, {name = basename .. "_on"})
mesecon:receptor_on(pos, mesecon.rules.pplate )
mesecon.receptor_on(pos, mesecon.rules.pplate )
-- force activation of mesecon two blocks below (hacky)
mesecon:turnon(two_below)
mesecon.turnon(two_below)
end
end
end
@ -49,7 +49,7 @@ end
-- image: inventory and wield image of the pressure plate
-- recipe: crafting recipe of the pressure plate
function mesecon:register_pressure_plate(basename, description, textures_off, textures_on, image_w, image_i, recipe)
function mesecon.register_pressure_plate(basename, description, textures_off, textures_on, image_w, image_i, recipe)
mesecon.register_node(basename, {
drawtype = "nodebox",
inventory_image = image_i,
@ -81,7 +81,7 @@ function mesecon:register_pressure_plate(basename, description, textures_off, te
})
end
mesecon:register_pressure_plate(
mesecon.register_pressure_plate(
"mesecons_pressureplates:pressure_plate_wood",
"Wooden Pressure Plate",
{"jeija_pressure_plate_wood_off.png","jeija_pressure_plate_wood_off.png","jeija_pressure_plate_wood_off_edges.png"},
@ -90,7 +90,7 @@ mesecon:register_pressure_plate(
"jeija_pressure_plate_wood_inv.png",
{{"group:wood", "group:wood"}})
mesecon:register_pressure_plate(
mesecon.register_pressure_plate(
"mesecons_pressureplates:pressure_plate_stone",
"Stone Pressure Plate",
{"jeija_pressure_plate_stone_off.png","jeija_pressure_plate_stone_off.png","jeija_pressure_plate_stone_off_edges.png"},

2
mesecons_random/init.lua
View File

@ -9,7 +9,7 @@ minetest.register_node("mesecons_random:removestone", {
mesecons = {effector = {
action_on = function (pos, node)
minetest.remove_node(pos)
mesecon:update_autoconnect(pos)
mesecon.update_autoconnect(pos)
end
}}
})

32
mesecons_receiver/init.lua
View File

@ -9,11 +9,11 @@ local receiver_get_rules = function (node)
local rules = { {x = 1, y = 0, z = 0},
{x = -2, y = 0, z = 0}}
if node.param2 == 2 then
rules = mesecon:rotate_rules_left(rules)
rules = mesecon.rotate_rules_left(rules)
elseif node.param2 == 3 then
rules = mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
rules = mesecon.rotate_rules_right(mesecon.rotate_rules_right(rules))
elseif node.param2 == 0 then
rules = mesecon:rotate_rules_right(rules)
rules = mesecon.rotate_rules_right(rules)
end
return rules
end
@ -81,15 +81,15 @@ minetest.register_node("mesecons_receiver:receiver_off", {
}}
})
function mesecon:receiver_get_pos_from_rcpt(pos, param2)
function mesecon.receiver_get_pos_from_rcpt(pos, param2)
local rules = {{x = 2, y = 0, z = 0}}
if param2 == nil then param2 = minetest.get_node(pos).param2 end
if param2 == 2 then
rules = mesecon:rotate_rules_left(rules)
rules = mesecon.rotate_rules_left(rules)
elseif param2 == 3 then
rules = mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
rules = mesecon.rotate_rules_right(mesecon.rotate_rules_right(rules))
elseif param2 == 0 then
rules = mesecon:rotate_rules_right(rules)
rules = mesecon.rotate_rules_right(rules)
end
np = {
x = pos.x + rules[1].x,
@ -98,16 +98,16 @@ function mesecon:receiver_get_pos_from_rcpt(pos, param2)
return np
end
function mesecon:receiver_place(rcpt_pos)
function mesecon.receiver_place(rcpt_pos)
local node = minetest.get_node(rcpt_pos)
local pos = mesecon:receiver_get_pos_from_rcpt(rcpt_pos, node.param2)
local pos = mesecon.receiver_get_pos_from_rcpt(rcpt_pos, node.param2)
local nn = minetest.get_node(pos)
if string.find(nn.name, "mesecons:wire_") ~= nil then
minetest.dig_node(pos)
if mesecon:is_power_on(rcpt_pos) then
if mesecon.is_power_on(rcpt_pos) then
minetest.add_node(pos, {name = "mesecons_receiver:receiver_on", param2 = node.param2})
mesecon:receptor_on(pos, receiver_get_rules(node))
mesecon.receptor_on(pos, receiver_get_rules(node))
else
minetest.add_node(pos, {name = "mesecons_receiver:receiver_off", param2 = node.param2})
end
@ -115,8 +115,8 @@ function mesecon:receiver_place(rcpt_pos)
end
end
function mesecon:receiver_remove(rcpt_pos, dugnode)
local pos = mesecon:receiver_get_pos_from_rcpt(rcpt_pos, dugnode.param2)
function mesecon.receiver_remove(rcpt_pos, dugnode)
local pos = mesecon.receiver_get_pos_from_rcpt(rcpt_pos, dugnode.param2)
local nn = minetest.get_node(pos)
if string.find(nn.name, "mesecons_receiver:receiver_") ~=nil then
minetest.dig_node(pos)
@ -129,13 +129,13 @@ end
minetest.register_on_placenode(function (pos, node)
if minetest.get_item_group(node.name, "mesecon_needs_receiver") == 1 then
mesecon:receiver_place(pos)
mesecon.receiver_place(pos)
end
end)
minetest.register_on_dignode(function(pos, node)
if minetest.get_item_group(node.name, "mesecon_needs_receiver") == 1 then
mesecon:receiver_remove(pos, node)
mesecon.receiver_remove(pos, node)
end
end)
@ -152,7 +152,7 @@ minetest.register_on_placenode(function (pos, node)
y = pos.y + rules[i].y,
z = pos.z + rules[i].z}
if minetest.get_item_group(minetest.get_node(np).name, "mesecon_needs_receiver") == 1 then
mesecon:receiver_place(np)
mesecon.receiver_place(np)
end
i = i + 1
end

4
mesecons_solarpanel/init.lua
View File

@ -75,7 +75,7 @@ minetest.register_abm(
if light >= 12 then
minetest.set_node(pos, {name="mesecons_solarpanel:solar_panel_on", param2=node.param2})
mesecon:receptor_on(pos)
mesecon.receptor_on(pos)
end
end,
})
@ -89,7 +89,7 @@ minetest.register_abm(
if light < 12 then
minetest.set_node(pos, {name="mesecons_solarpanel:solar_panel_off", param2=node.param2})
mesecon:receptor_off(pos)
mesecon.receptor_off(pos)
end
end,
})

4
mesecons_switch/init.lua
View File

@ -11,7 +11,7 @@ minetest.register_node("mesecons_switch:mesecon_switch_off", {
}},
on_punch = function(pos, node)
minetest.swap_node(pos, {name = "mesecons_switch:mesecon_switch_on", param2 = node.param2})
mesecon:receptor_on(pos)
mesecon.receptor_on(pos)
minetest.sound_play("mesecons_switch", {pos=pos})
end
})
@ -27,7 +27,7 @@ minetest.register_node("mesecons_switch:mesecon_switch_on", {
}},
on_punch = function(pos, node)
minetest.swap_node(pos, {name = "mesecons_switch:mesecon_switch_off", param2 = node.param2})
mesecon:receptor_off(pos)
mesecon.receptor_off(pos)
minetest.sound_play("mesecons_switch", {pos=pos})
end
})

18
mesecons_torch/init.lua
View File

@ -2,15 +2,15 @@
local rotate_torch_rules = function (rules, param2)
if param2 == 5 then
return mesecon:rotate_rules_right(rules)
return mesecon.rotate_rules_right(rules)
elseif param2 == 2 then
return mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules)) --180 degrees
return mesecon.rotate_rules_right(mesecon.rotate_rules_right(rules)) --180 degrees
elseif param2 == 4 then
return mesecon:rotate_rules_left(rules)
return mesecon.rotate_rules_left(rules)
elseif param2 == 1 then
return mesecon:rotate_rules_down(rules)
return mesecon.rotate_rules_down(rules)
elseif param2 == 0 then
return mesecon:rotate_rules_up(rules)
return mesecon.rotate_rules_up(rules)
else
return rules
end
@ -91,8 +91,8 @@ minetest.register_abm({
action = function(pos, node)
local is_powered = false
for _, rule in ipairs(torch_get_input_rules(node)) do
local src = mesecon:addPosRule(pos, rule)
if mesecon:is_power_on(src) then
local src = mesecon.addPosRule(pos, rule)
if mesecon.is_power_on(src) then
is_powered = true
end
end
@ -100,11 +100,11 @@ minetest.register_abm({
if is_powered then
if node.name == "mesecons_torch:mesecon_torch_on" then
minetest.swap_node(pos, {name = "mesecons_torch:mesecon_torch_off", param2 = node.param2})
mesecon:receptor_off(pos, torch_get_output_rules(node))
mesecon.receptor_off(pos, torch_get_output_rules(node))
end
elseif node.name == "mesecons_torch:mesecon_torch_off" then
minetest.swap_node(pos, {name = "mesecons_torch:mesecon_torch_on", param2 = node.param2})
mesecon:receptor_on(pos, torch_get_output_rules(node))
mesecon.receptor_on(pos, torch_get_output_rules(node))
end
end
})

4
mesecons_walllever/init.lua
View File

@ -33,7 +33,7 @@ minetest.register_node("mesecons_walllever:wall_lever_off", {
description="Lever",
on_punch = function (pos, node)
minetest.swap_node(pos, {name = "mesecons_walllever:wall_lever_on", param2 = node.param2})
mesecon:receptor_on(pos, mesecon.rules.buttonlike_get(node))
mesecon.receptor_on(pos, mesecon.rules.buttonlike_get(node))
minetest.sound_play("mesecons_lever", {pos=pos})
end,
sounds = default.node_sound_wood_defaults(),
@ -75,7 +75,7 @@ minetest.register_node("mesecons_walllever:wall_lever_on", {
description="Lever",
on_punch = function (pos, node)
minetest.swap_node(pos, {name = "mesecons_walllever:wall_lever_off", param2 = node.param2})
mesecon:receptor_off(pos, mesecon.rules.buttonlike_get(node))
mesecon.receptor_off(pos, mesecon.rules.buttonlike_get(node))
minetest.sound_play("mesecons_lever", {pos=pos})
end,
sounds = default.node_sound_wood_defaults(),