Version 0.41.3

[MineClone/MineClone2/MineClone2-Fixes.git] / mods / ITEMS / REDSTONE / mesecons / internal.lua

-- Internal.lua - The core of mesecons
--
-- For more practical developer resources see http://mesecons.net/developers.php
--
-- Function overview
-- mesecon.get_effector(nodename)       --> Returns the mesecons.effector -specifictation in the nodedef by the nodename
-- mesecon.get_receptor(nodename)       --> Returns the mesecons.receptor -specifictation in the nodedef by the nodename
-- mesecon.get_conductor(nodename)      --> Returns the mesecons.conductor-specifictation in the nodedef by the nodename
-- mesecon.get_any_inputrules (node)    --> Returns the rules of a node if it is a conductor or an effector
-- mesecon.get_any_outputrules (node)   --> Returns the rules of a node if it is a conductor or a receptor

-- 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)

-- 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)

-- 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

-- 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)

-- 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.is_powered(pos)                              --> Returns bool, spread. bool is true if pos is powered by a receptor, a conductor or an opaque block.
                                                        --  spread is true if it is powered AND also transmits its power one block further.

-- RULES ROTATION helpers
-- mesecon.rotate_rules_right(rules)
-- mesecon.rotate_rules_left(rules)
-- mesecon.rotate_rules_up(rules)
-- mesecon.rotate_rules_down(rules)
-- These functions return rules that have been rotated in the specific direction

-- General
function mesecon.get_effector(nodename)
        if  minetest.registered_nodes[nodename]
        and minetest.registered_nodes[nodename].mesecons
        and minetest.registered_nodes[nodename].mesecons.effector then
                return minetest.registered_nodes[nodename].mesecons.effector
        end
end

function mesecon.get_receptor(nodename)
        if  minetest.registered_nodes[nodename]
        and minetest.registered_nodes[nodename].mesecons
        and minetest.registered_nodes[nodename].mesecons.receptor then
                return minetest.registered_nodes[nodename].mesecons.receptor
        end
end

function mesecon.get_conductor(nodename)
        if  minetest.registered_nodes[nodename]
        and minetest.registered_nodes[nodename].mesecons
        and minetest.registered_nodes[nodename].mesecons.conductor then
                return minetest.registered_nodes[nodename].mesecons.conductor
        end
end

function mesecon.get_any_outputrules(node)
        if not node then return nil end

        if mesecon.is_conductor(node.name) then
                return mesecon.conductor_get_rules(node)
        elseif mesecon.is_receptor(node.name) then
                return mesecon.receptor_get_rules(node)
        elseif minetest.get_item_group(node.name, "opaque") == 1 then
                return mesecon.rules.alldirs
        end
end

function mesecon.get_any_inputrules(node)
        if not node then return nil end

        if mesecon.is_conductor(node.name) then
                return mesecon.conductor_get_rules(node)
        elseif mesecon.is_effector(node.name) then
                return mesecon.effector_get_rules(node)
        elseif minetest.get_item_group(node.name, "opaque") == 1 then
                return mesecon.rules.alldirs
        end
end

function mesecon.get_any_rules(node)
        return mesecon.mergetable(mesecon.get_any_inputrules(node) or {},
                mesecon.get_any_outputrules(node) or {})
end

-- Receptors
-- Nodes that can power mesecons
function mesecon.is_receptor_on(nodename)
        local receptor = mesecon.get_receptor(nodename)
        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)
        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)
        if receptor then
                return true
        end
        return false
end

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
                        return rules(node)
                elseif rules then
                        return rules
                end
        end

        return mesecon.rules.default
end

-- Effectors
-- Nodes that can be powered by mesecons
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)
        if effector and effector.action_on then
                return true
        end
        return false
end

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)
        if effector then
                local rules = effector.rules
                if type(rules) == 'function' then
                        return rules(node)
                elseif rules then
                        return rules
                end
        end
        return mesecon.rules.default
end

-- #######################
-- # Signals (effectors) #
-- #######################

-- Activation:
mesecon.queue:add_function("activate", function (pos, rulename)
        local node = mesecon.get_node_force(pos)
        if not node then return end

        local effector = mesecon.get_effector(node.name)

        if effector and effector.action_on then
                effector.action_on(pos, node, rulename)
        end
end)

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)
                end
                return
        end
        mesecon.queue:add_action(pos, "activate", {rulename}, nil, rulename, 1 / depth)
end


-- Deactivation
mesecon.queue:add_function("deactivate", function (pos, rulename)
        local node = mesecon.get_node_force(pos)
        if not node then return end

        local effector = mesecon.get_effector(node.name)

        if effector and effector.action_off then
                effector.action_off(pos, node, rulename)
        end
end)

function mesecon.deactivate(pos, node, rulename, depth)
        if rulename == nil then
                for _,rule in ipairs(mesecon.effector_get_rules(node)) do
                        mesecon.deactivate(pos, node, rule, depth + 1)
                end
                return
        end
        mesecon.queue:add_action(pos, "deactivate", {rulename}, nil, rulename, 1 / depth)
end


-- Change
mesecon.queue:add_function("change", function (pos, rulename, changetype)
        local node = mesecon.get_node_force(pos)
        if not node then return end

        local effector = mesecon.get_effector(node.name)

        if effector and effector.action_change then
                effector.action_change(pos, node, rulename, changetype)
        end
end)

function mesecon.changesignal(pos, node, rulename, newstate, depth)
        if rulename == nil then
                for _,rule in ipairs(mesecon.effector_get_rules(node)) do
                        mesecon.changesignal(pos, node, rule, newstate, depth + 1)
                end
                return
        end

        -- Include "change" in overwritecheck so that it cannot be overwritten
        -- by "active" / "deactivate" that will be called upon the node at the same time.
        local overwritecheck = {"change", rulename}
        mesecon.queue:add_action(pos, "change", {rulename, newstate}, nil, overwritecheck, 1 / depth)
end

-- Conductors

function mesecon.is_conductor_on(node, rulename)
        if not node then return false end

        local conductor = mesecon.get_conductor(node.name)
        if conductor then
                if conductor.state then
                        return conductor.state == mesecon.state.on
                end
                if conductor.states then
                        if not rulename then
                                return mesecon.getstate(node.name, conductor.states) ~= 1
                        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)
                end
        end

        return false
end

function mesecon.is_conductor_off(node, rulename)
        if not node then return false end

        local conductor = mesecon.get_conductor(node.name)
        if conductor then
                if conductor.state then
                        return conductor.state == mesecon.state.off
                end
                if conductor.states then
                        if not rulename then
                                return mesecon.getstate(node.name, conductor.states) == 1
                        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)
                end
        end

        return false
end

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)
        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")
                        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)
        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")
                        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)
        if conductor then
                local rules = conductor.rules
                if type(rules) == 'function' then
                        return rules(node)
                elseif rules then
                        return rules
                end
        end
        return mesecon.rules.default
end

-- some more general high-level stuff

function mesecon.is_power_on(pos, rulename)
        local node = mesecon.get_node_force(pos)
        if node and (mesecon.is_conductor_on(node, rulename) or mesecon.is_receptor_on(node.name)) then
                return true
        end
        return false
end

function mesecon.is_power_off(pos, rulename)
        local node = mesecon.get_node_force(pos)
        if node and (mesecon.is_conductor_off(node, rulename) or mesecon.is_receptor_off(node.name)) then
                return true
        end
        return false
end

-- Turn off an equipotential section starting at `pos`, which outputs in the direction of `link`.
-- Breadth-first search. Map is abstracted away in a voxelmanip.
-- Follow all all conductor paths replacing conductors that were already
-- looked at, activating / changing all effectors along the way.
function mesecon.turnon(pos, link)
        local frontiers = {{pos = pos, link = link}}

        local depth = 1
        while frontiers[1] do
                local f = table.remove(frontiers, 1)
                local node = mesecon.get_node_force(f.pos)

                if not node then
                        -- Area does not exist; do nothing
                elseif mesecon.is_conductor_off(node, f.link) then
                        local rules = mesecon.conductor_get_rules(node)

                        -- Call turnon on neighbors
                        for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
                                local np = vector.add(f.pos, r)
                                for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
                                        table.insert(frontiers, {pos = np, link = l})
                                end
                        end

                        mesecon.swap_node_force(f.pos, mesecon.get_conductor_on(node, f.link))
                elseif mesecon.is_effector(node.name) then
                        mesecon.changesignal(f.pos, node, f.link, mesecon.state.on, depth)
                        if mesecon.is_effector_off(node.name) then
                                mesecon.activate(f.pos, node, f.link, depth)
                        end
                end
                if node and f.link.spread and minetest.get_item_group(node.name, "opaque") == 1 then
                        -- Call turnon on neighbors
                        -- Warning: A LOT of nodes need to be looked at for this to work
                        for _, r in ipairs(mesecon.rule2meta(f.link, mesecon.rules.mcl_alldirs_spread)) do
                                local np = vector.add(f.pos, r)
                                for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
                                        local nlink = table.copy(l)
                                        nlink.spread = false
                                        table.insert(frontiers, {pos = np, link = nlink})
                                end
                        end
                end

                depth = depth + 1
        end
end

-- Turn off an equipotential section starting at `pos`, which outputs in the direction of `link`.
-- Breadth-first search. Map is abstracted away in a voxelmanip.
-- Follow all all conductor paths replacing conductors that were already
-- looked at, deactivating / changing all effectors along the way.
-- In case an onstate receptor is discovered, abort the process by returning false, which will
-- cause `receptor_off` to discard all changes made in the voxelmanip.
-- Contrary to turnon, turnoff has to cache all change and deactivate signals so that they will only
-- be called in the very end when we can be sure that no conductor was found along the path.
--
-- Signal table entry structure:
-- {
--      pos = position of effector,
--      node = node descriptor (name, param1 and param2),
--      link = link the effector is connected to,
--      depth = indicates order in which signals wire fired, higher is later
-- }
function mesecon.turnoff(pos, link)
        local frontiers = {{pos = pos, link = link}}
        local signals = {}

        local depth = 1
        while frontiers[1] do
                local f = table.remove(frontiers, 1)
                local node = mesecon.get_node_force(f.pos)

                if not node then
                        -- No-op
                elseif mesecon.is_conductor_on(node, f.link) then
                        local rules = mesecon.conductor_get_rules(node)
                        for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
                                local np = vector.add(f.pos, r)

                                -- Check if an onstate receptor is connected. If that is the case,
                                -- abort this turnoff process by returning false. `receptor_off` will
                                -- discard all the changes that we made in the voxelmanip:
                                for _, l in ipairs(mesecon.rules_link_rule_all_inverted(f.pos, r)) do
                                        if mesecon.is_receptor_on(mesecon.get_node_force(np).name) then
                                                return false
                                        end
                                end

                                -- Call turnoff on neighbors
                                for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
                                        table.insert(frontiers, {pos = np, link = l})
                                end
                        end

                        mesecon.swap_node_force(f.pos, mesecon.get_conductor_off(node, f.link))
                elseif mesecon.is_effector(node.name) then
                        table.insert(signals, {
                                pos = f.pos,
                                node = node,
                                link = f.link,
                                depth = depth
                        })
                end

                if node and f.link.spread and minetest.get_item_group(node.name, "opaque") == 1 then
                        -- Call turnoff on neighbors
                        -- Warning: A LOT of nodes need to be looked at for this to work
                        for _, r in ipairs(mesecon.rule2meta(f.link, mesecon.rules.mcl_alldirs_spread)) do
                                local np = vector.add(f.pos, r)
                                local n = mesecon.get_node_force(np)
                                if mesecon.is_receptor_on(n.name) then
                                        local receptorrules = mesecon.receptor_get_rules(n)
                                        for _, rr in pairs(receptorrules) do
                                                if rr.spread and vector.equals(mesecon.invertRule(rr), r) then
                                                        return false
                                                end
                                        end
                                end
                                for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
                                        local nlink = table.copy(l)
                                        nlink.spread = false
                                        table.insert(frontiers, {pos = np, link = nlink})
                                end
                        end
                end

                depth = depth + 1
        end

        for _, sig in ipairs(signals) do
                mesecon.changesignal(sig.pos, sig.node, sig.link, mesecon.state.off, sig.depth)
                if mesecon.is_effector_on(sig.node.name) and not mesecon.is_powered(sig.pos) then
                        mesecon.deactivate(sig.pos, sig.node, sig.link, sig.depth)
                end
        end

        return true
end

-- Get all linking inputrules of inputnode (effector or conductor) that is connected to
-- outputnode (receptor or conductor) at position `output` and has an output in direction `rule`
function mesecon.rules_link_rule_all(output, rule)
        local input = vector.add(output, rule)
        local inputnode = mesecon.get_node_force(input)
        local inputrules = mesecon.get_any_inputrules(inputnode)
        if not inputrules then
                return {}
        end
        local rules = {}

        for _, inputrule in ipairs(mesecon.flattenrules(inputrules)) do
                -- Check if input accepts from output
                if vector.equals(vector.add(input, inputrule), output) then
                        local newrule = table.copy(inputrule)
                        newrule.spread = rule.spread
                        table.insert(rules, newrule)
                end
        end

        return rules
end

-- Get all linking outputnodes of outputnode (receptor or conductor) that is connected to
-- inputnode (effector or conductor) at position `input` and has an input in direction `rule`
function mesecon.rules_link_rule_all_inverted(input, rule)
        local output = vector.add(input, rule)
        local outputnode = mesecon.get_node_force(output)
        local outputrules = mesecon.get_any_outputrules(outputnode)
        if not outputrules then
                return {}
        end
        local rules = {}

        for _, outputrule in ipairs(mesecon.flattenrules(outputrules)) do
                if vector.equals(vector.add(output, outputrule), input) then
                        local newrule = table.copy(outputrule)
                        newrule = mesecon.invertRule(newrule)
                        newrule.spread = rule.spread
                        table.insert(rules, newrule)
                end
        end
        return rules
end

function mesecon.is_powered(pos, rule, depth, sourcepos, home_pos)
        if depth == nil then depth = 0 end
        if depth > 1 then
                return false, false
        end
        local node = mesecon.get_node_force(pos)
        local rules = mesecon.get_any_inputrules(node)
        if not rules then
                return false, false
        end
        if not home_pos then
                home_pos = pos
        end

        -- List of nodes that send out power to pos
        if sourcepos == nil then
                sourcepos = {}
        end

        local function power_walk(pos, home_pos, sourcepos, rulenames, rule, depth)
                local spread = false
                for _, rname in ipairs(rulenames) do
                        local np = vector.add(pos, rname)
                        local nn = mesecon.get_node_force(np)
                        if (mesecon.is_conductor_on (nn, mesecon.invertRule(rname))
                        or mesecon.is_receptor_on (nn.name)) then
                                if not vector.equals(home_pos, np) then
                                        local rulez = mesecon.get_any_outputrules(nn)
                                        local spread_tmp = false
                                        for r=1, #rulez do
                                                if vector.equals(mesecon.invertRule(rname), rulez[r]) then
                                                        if rulez[r].spread then
                                                                spread_tmp = true
                                                        end
                                                end
                                        end
                                        if depth == 0 or spread_tmp then
                                                table.insert(sourcepos, np)
                                                if spread_tmp then
                                                        spread = true
                                                end
                                        end
                                end
                        elseif depth == 0 and minetest.get_item_group(nn.name, "opaque") == 1 then
                                local more_sourcepos = mesecon.is_powered(np, nil, depth + 1, sourcepos, home_pos)
                                if more_sourcepos and #more_sourcepos > 0 then
                                        mesecon.mergetable(sourcepos, more_sourcepos)
                                end
                        end
                end
                return sourcepos, spread
        end

        local spread = false
        if not rule then
                for _, rule in ipairs(mesecon.flattenrules(rules)) do
                        local spread_temp
                        local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
                        sourcepos, spread_temp = power_walk(pos, home_pos, sourcepos, rulenames, rule, depth)
                        if spread_temp then
                                spread = true
                        end
                end
        else
                local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
                sourcepos, spread = power_walk(pos, home_pos, sourcepos, rulenames, rule, depth)
        end

        -- Return FALSE if not powered, return list of sources if is powered

        if (#sourcepos == 0) then
                return false, false
        else
                return sourcepos, spread
        end
end