minetest-mods/mesecons
1
0
Fork 2
mirror of https://github.com/minetest-mods/mesecons.git synced 2024-12-26 02:10:18 +01:00
Code Issues Releases Wiki Activity

Merge branch 'mesecons_in_nodedef'

Browse Source 
Conflicts:
	mesecons/internal.lua
This commit is contained in:
Jeija 2012-12-11 19:49:55 +01:00
commit de46729b97
56 changed files with 1306 additions and 1415 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
mesecons/init.lua
View File

@ -3,63 +3,82 @@
-- | \/ | |___ ____ |___ | | | | \ | |____
-- | | | | | | | | | \ | |
-- | | |___ ____| |___ |____ |____| | \| ____|
-- by Jeija and Minerd247
-- by Jeija, Uberi (Temperest), sfan5, VanessaE
--
--
--
-- This mod adds mesecons[=minecraft redstone] and different receptors/effectors to minetest.
--
-- See the documentation on the forum for additional information, especially about crafting
--
-- For developer documentation see the Developers' section on mesecons.tk
--
-- For developer documentation see the Developers' section on mesecons.TK
--
--
--
--Quick draft for the mesecons array in the node's definition
--mesecons =
--{
-- receptor =
-- {
-- state = mesecon.state.on/off
-- rules = rules/get_rules
-- }
-- effector =
-- {
-- action_on = function
-- action_off = function
-- action_change = function
-- rules = rules/get_rules
-- }
-- conductor =
-- {
-- state = mesecon.state.on/off
-- offstate = opposite state (for state = on only)
-- onstate = opposite state (for state = off only)
-- rules = rules/get_rules
-- }
--}
-- PUBLIC VARIABLES
mesecon={} -- contains all functions and all global variables
mesecon.actions_on={} -- Saves registered function callbacks for mesecon on
mesecon.actions_off={} -- Saves registered function callbacks for mesecon off
mesecon.actions_change={} -- Saves registered function callbacks for mesecon change
mesecon.receptors={}
mesecon.effectors={}
mesecon.rules={}
mesecon.conductors={}
mesecon.actions_on={} -- Saves registered function callbacks for mesecon on | DEPRECATED
mesecon.actions_off={} -- Saves registered function callbacks for mesecon off | DEPRECATED
mesecon.actions_change={} -- Saves registered function callbacks for mesecon change | DEPRECATED
mesecon.receptors={} -- saves all information about receptors | DEPRECATED
mesecon.effectors={} -- saves all information about effectors | DEPRECATED
mesecon.conductors={} -- saves all information about conductors | DEPRECATED
-- INCLUDE SETTINGS
-- Settings
dofile(minetest.get_modpath("mesecons").."/settings.lua")
--Internal API
-- Presets (eg default rules)
dofile(minetest.get_modpath("mesecons").."/presets.lua");
-- Utilities like comparing positions,
-- adding positions and rules,
-- mostly things that make the source look cleaner
dofile(minetest.get_modpath("mesecons").."/util.lua");
-- Internal stuff
-- This is the most important file
-- it handles signal transmission and basically everything else
-- It is also responsible for managing the nodedef things,
-- like calling action_on/off/change
dofile(minetest.get_modpath("mesecons").."/internal.lua");
-- API API API API API API API API API API API API API API API API API API
-- Deprecated stuff
-- To be removed in future releases
dofile(minetest.get_modpath("mesecons").."/legacy.lua");
function mesecon:register_receptor(onstate, offstate, rules, get_rules)
if get_rules == nil and rules == nil then
rules = mesecon:get_rules("default")
end
table.insert(mesecon.receptors,
{onstate = onstate,
offstate = offstate,
rules = rules,
get_rules = get_rules})
end
function mesecon:register_effector(onstate, offstate, input_rules, get_input_rules)
if get_input_rules==nil and input_rules==nil then
rules=mesecon:get_rules("default")
end
table.insert(mesecon.effectors,
{onstate = onstate,
offstate = offstate,
input_rules = input_rules,
get_input_rules = get_input_rules})
end
-- API
-- these are the only functions you need to remember
function mesecon:receptor_on(pos, rules)
if rules == nil then
rules = mesecon:get_rules("default")
end
rules = rules or mesecon.rules.default
for i, rule in ipairs(rules) do
for _, rule in ipairs(rules) do
local np = {
x = pos.x + rule.x,
y = pos.y + rule.y,
@ -71,11 +90,9 @@ function mesecon:receptor_on(pos, rules)
end
function mesecon:receptor_off(pos, rules)
if rules == nil then
rules = mesecon:get_rules("default")
end
rules = rules or mesecon.rules.default
for i, rule in ipairs(rules) do
for _, rule in ipairs(rules) do
local np = {
x = pos.x + rule.x,
y = pos.y + rule.y,
@ -86,45 +103,11 @@ function mesecon:receptor_off(pos, rules)
end
end
function mesecon:register_on_signal_on(action)
table.insert(mesecon.actions_on, action)
end
function mesecon:register_on_signal_off(action)
table.insert(mesecon.actions_off, action)
end
function mesecon:register_on_signal_change(action)
table.insert(mesecon.actions_change, action)
end
function mesecon:register_conductor (onstate, offstate, rules, get_rules)
if rules == nil then
rules = mesecon:get_rules("default")
end
table.insert(mesecon.conductors, {onstate = onstate, offstate = offstate, rules = rules, get_rules = get_rules})
end
mesecon:add_rules("default",
{{x=0, y=0, z=-1},
{x=1, y=0, z=0},
{x=-1, y=0, z=0},
{x=0, y=0, z=1},
{x=1, y=1, z=0},
{x=1, y=-1, z=0},
{x=-1, y=1, z=0},
{x=-1, y=-1, z=0},
{x=0, y=1, z=1},
{x=0, y=-1, z=1},
{x=0, y=1, z=-1},
{x=0, y=-1, z=-1}})
print("[MESEcons] Main mod Loaded!")
print("[OK] mesecons")
--The actual wires
dofile(minetest.get_modpath("mesecons").."/wires.lua");
--Services like turnoff receptor on dignode and so on
dofile(minetest.get_modpath("mesecons").."/services.lua");
--Deprecated stuff
dofile(minetest.get_modpath("mesecons").."/legacy.lua");

241
mesecons/internal.lua
View File

@ -1,7 +1,14 @@
-- INTERNAL
--Receptors
-- Receptors
-- Nodes that can power mesecons
function mesecon:is_receptor_node(nodename)
if minetest.registered_nodes[nodename]
and minetest.registered_nodes[nodename].mesecons
and minetest.registered_nodes[nodename].mesecons.receptor
and minetest.registered_nodes[nodename].mesecons.receptor.state == mesecon.state.on then
return true
end
for _, receptor in ipairs(mesecon.receptors) do
if receptor.onstate == nodename then
return true
@ -11,6 +18,12 @@ function mesecon:is_receptor_node(nodename)
end
function mesecon:is_receptor_node_off(nodename, pos, ownpos)
if minetest.registered_nodes[nodename]
and minetest.registered_nodes[nodename].mesecons
and minetest.registered_nodes[nodename].mesecons.receptor
and minetest.registered_nodes[nodename].mesecons.receptor.state == mesecon.state.off then
return true
end
for _, receptor in ipairs(mesecon.receptors) do
if receptor.offstate == nodename then
return true
@ -20,7 +33,16 @@ function mesecon:is_receptor_node_off(nodename, pos, ownpos)
end
function mesecon:receptor_get_rules(node)
for i, receptor in ipairs(mesecon.receptors) do
if minetest.registered_nodes[node.name].mesecons
and minetest.registered_nodes[node.name].mesecons.receptor then
local rules = minetest.registered_nodes[node.name].mesecons.receptor.rules
if type(rules) == 'function' then
return rules(node)
elseif rules then
return rules
end
end
for _, receptor in ipairs(mesecon.receptors) do --TODO
if receptor.onstate == node.name or receptor.offstate == node.name then
if receptor.get_rules ~= nil then
return receptor.get_rules(node.param2)
@ -31,12 +53,19 @@ function mesecon:receptor_get_rules(node)
end
end
end
return nil
return mesecon.rules.default
end
-- Effectors
-- Nodes that can be powered by mesecons
function mesecon:is_effector_on(nodename)
for i, effector in ipairs(mesecon.effectors) do
if minetest.registered_nodes[nodename]
and minetest.registered_nodes[nodename].mesecons
and minetest.registered_nodes[nodename].mesecons.effector
and minetest.registered_nodes[nodename].mesecons.effector.action_off then
return true
end
for _, effector in ipairs(mesecon.effectors) do --TODO
if effector.onstate == nodename then
return true
end
@ -45,7 +74,13 @@ function mesecon:is_effector_on(nodename)
end
function mesecon:is_effector_off(nodename)
for i, effector in ipairs(mesecon.effectors) do
if minetest.registered_nodes[nodename]
and minetest.registered_nodes[nodename].mesecons
and minetest.registered_nodes[nodename].mesecons.effector
and minetest.registered_nodes[nodename].mesecons.effector.action_on then
return true
end
for _, effector in ipairs(mesecon.effectors) do --TODO
if effector.offstate == nodename then
return true
end
@ -54,43 +89,73 @@ function mesecon:is_effector_off(nodename)
end
function mesecon:is_effector(nodename)
return mesecon:is_effector_on(nodename) or mesecon:is_effector_off(nodename)
if minetest.registered_nodes[nodename]
and minetest.registered_nodes[nodename].mesecons
and minetest.registered_nodes[nodename].mesecons.effector then
return true
end
return mesecon:is_effector_on(nodename) or mesecon:is_effector_off(nodename) --TODO
end
function mesecon:effector_get_input_rules(node)
for i, effector in ipairs(mesecon.effectors) do
if minetest.registered_nodes[node.name].mesecons
and minetest.registered_nodes[node.name].mesecons.effector then
local rules = minetest.registered_nodes[node.name].mesecons.effector.rules
if type(rules) == 'function' then
return rules(node)
elseif rules then
return rules
end
end
for _, effector in ipairs(mesecon.effectors) do
if effector.onstate == node.name
or effector.offstate == node.name then
if effector.get_input_rules ~= nil then
return effector.get_input_rules(node.param2)
elseif mesecon.effectors[i].input_rules ~=nil then
elseif effector.input_rules ~=nil then
return effector.input_rules
else
return mesecon:get_rules("default")
end
end
end
return mesecon.rules.default
end
--Signals
function mesecon:activate(pos)
local node = minetest.env:get_node(pos)
for i, action in ipairs(mesecon.actions_on) do
function mesecon:activate(pos, node)
if minetest.registered_nodes[node.name]
and minetest.registered_nodes[node.name].mesecons
and minetest.registered_nodes[node.name].mesecons.effector
and minetest.registered_nodes[node.name].mesecons.effector.action_on then
minetest.registered_nodes[node.name].mesecons.effector.action_on (pos, node)
end
for _, action in ipairs(mesecon.actions_on) do --TODO
action(pos, node)
end
end
function mesecon:deactivate(pos)
local node = minetest.env:get_node(pos)
for i, action in ipairs(mesecon.actions_off) do
function mesecon:deactivate(pos, node) --TODO
if minetest.registered_nodes[node.name]
and minetest.registered_nodes[node.name].mesecons
and minetest.registered_nodes[node.name].mesecons.effector
and minetest.registered_nodes[node.name].mesecons.effector.action_off then
minetest.registered_nodes[node.name].mesecons.effector.action_off(pos, node)
end
for _, action in ipairs(mesecon.actions_off) do
action(pos, node)
end
end
function mesecon:changesignal(pos)
local node = minetest.env:get_node(pos)
for i, action in ipairs(mesecon.actions_change) do
function mesecon:changesignal(pos, node) --TODO
if minetest.registered_nodes[node.name]
and minetest.registered_nodes[node.name].mesecons
and minetest.registered_nodes[node.name].mesecons.effector
and minetest.registered_nodes[node.name].mesecons.effector.action_change then
minetest.registered_nodes[node.name].mesecons.effector.action_change(pos, node)
end
for _, action in ipairs(mesecon.actions_change) do
action(pos, node)
end
end
@ -98,21 +163,22 @@ end
--Rules
function mesecon:add_rules(name, rules)
table.insert(mesecon.rules, {name = name, rules = rules})
mesecon.rules[name] = rules
end
function mesecon:get_rules(name)
for i, rule in ipairs(mesecon.rules) do
if rule.name==name then
return rule.rules
end
end
return mesecon.rules[name]
end
--Conductor system stuff
-- Conductors
function mesecon:get_conductor_on(offstate)
for i, conductor in ipairs(mesecon.conductors) do
if minetest.registered_nodes[offstate]
and minetest.registered_nodes[offstate].mesecons
and minetest.registered_nodes[offstate].mesecons.conductor then
return minetest.registered_nodes[offstate].mesecons.conductor.onstate
end
for _, conductor in ipairs(mesecon.conductors) do --TODO
if conductor.offstate == offstate then
return conductor.onstate
end
@ -121,7 +187,12 @@ function mesecon:get_conductor_on(offstate)
end
function mesecon:get_conductor_off(onstate)
for i, conductor in ipairs(mesecon.conductors) do
if minetest.registered_nodes[onstate]
and minetest.registered_nodes[onstate].mesecons
and minetest.registered_nodes[onstate].mesecons.conductor then
return minetest.registered_nodes[onstate].mesecons.conductor.offstate
end
for _, conductor in ipairs(mesecon.conductors) do --TODO
if conductor.onstate == onstate then
return conductor.offstate
end
@ -129,30 +200,53 @@ function mesecon:get_conductor_off(onstate)
return false
end
function mesecon:is_conductor_on(name)
for i, conductor in ipairs(mesecon.conductors) do
if conductor.onstate == name then
function mesecon:is_conductor_on(nodename)
if minetest.registered_nodes[nodename]
and minetest.registered_nodes[nodename].mesecons
and minetest.registered_nodes[nodename].mesecons.conductor
and minetest.registered_nodes[nodename].mesecons.conductor.state == mesecon.state.on then
return true
end
for _, conductor in ipairs(mesecon.conductors) do --TODO
if conductor.onstate == nodename then
return true
end
end
return false
end
function mesecon:is_conductor_off(name)
for i, conductor in ipairs(mesecon.conductors) do
if conductor.offstate == name then
function mesecon:is_conductor_off(nodename)
if minetest.registered_nodes[nodename]
and minetest.registered_nodes[nodename].mesecons
and minetest.registered_nodes[nodename].mesecons.conductor
and minetest.registered_nodes[nodename].mesecons.conductor.state == mesecon.state.off then
return true
end
for _, conductor in ipairs(mesecon.conductors) do --TODO
if conductor.offstate == nodename then
return true
end
end
return false
end
function mesecon:is_conductor(name)
return mesecon:is_conductor_on(name) or mesecon:is_conductor_off(name)
function mesecon:is_conductor(nodename)
--TODO
return mesecon:is_conductor_on(nodename) or mesecon:is_conductor_off(nodename)
end
function mesecon:conductor_get_rules(node)
for i, conductor in ipairs(mesecon.conductors) do
if minetest.registered_nodes[node.name]
and minetest.registered_nodes[node.name].mesecons
and minetest.registered_nodes[node.name].mesecons.conductor then
local rules = minetest.registered_nodes[node.name].mesecons.conductor.rules
if type(rules) == 'function' then
return rules(node)
elseif rules then
return rules
end
end
for _, conductor in ipairs(mesecon.conductors) do --TODO
if conductor.onstate == node.name
or conductor.offstate == node.name then
if conductor.get_rules ~= nil then
@ -162,6 +256,7 @@ function mesecon:conductor_get_rules(node)
end
end
end
return mesecon.rules.default
end
--
@ -186,13 +281,10 @@ function mesecon:turnon(pos)
if mesecon:is_conductor_off(node.name) then
local rules = mesecon:conductor_get_rules(node)
minetest.env:add_node(pos, {name=mesecon:get_conductor_on(node.name), param2 = node.param2})
mesecon:swap_node(pos, mesecon:get_conductor_on(node.name))
for i, rule in ipairs(rules) do
local np = {}
np.x = pos.x + rule.x
np.y = pos.y + rule.y
np.z = pos.z + rule.z
for _, rule in ipairs(rules) do
local np = mesecon:addPosRule(pos, rule)
if mesecon:rules_link(pos, np) then
mesecon:turnon(np)
@ -201,25 +293,22 @@ function mesecon:turnon(pos)
end
if mesecon:is_effector(node.name) then
mesecon:changesignal(pos)
if mesecon:is_effector_off(node.name) then mesecon:activate(pos) end
mesecon:changesignal(pos, node)
if mesecon:is_effector_off(node.name) then
mesecon:activate(pos, node)
end
end
end
function mesecon:turnoff(pos) --receptor rules used because output could have been dug
local node = minetest.env:get_node(pos)
local rules
if mesecon:is_conductor_on(node.name) then
rules = mesecon:conductor_get_rules(node)
local rules = mesecon:conductor_get_rules(node)
mesecon:swap_node(pos, mesecon:get_conductor_off(node.name))
minetest.env:add_node(pos, {name=mesecon:get_conductor_off(node.name), param2 = node.param2})
for i, rule in ipairs(rules) do
local np = {
x = pos.x + rule.x,
y = pos.y + rule.y,
z = pos.z + rule.z,}
for _, rule in ipairs(rules) do
local np = mesecon:addPosRule(pos, rule)
if mesecon:rules_link(pos, np) then
mesecon:turnoff(np)
@ -228,8 +317,11 @@ function mesecon:turnoff(pos) --receptor rules used because output could have be
end
if mesecon:is_effector(node.name) then
mesecon:changesignal(pos)
if mesecon:is_effector_on(node.name) and not mesecon:is_powered(pos) then mesecon:deactivate(pos) end
mesecon:changesignal(pos, node)
if mesecon:is_effector_on(node.name)
and not mesecon:is_powered(pos) then
mesecon:deactivate(pos, node)
end
end
end
@ -238,7 +330,7 @@ function mesecon:connected_to_pw_src(pos, checked)
local c = 1
checked = checked or {}
while checked[c] ~= nil do --find out if node has already been checked (to prevent from endless loop)
if compare_pos(checked[c], pos) then
if mesecon:cmpPos(checked[c], pos) then
return false, checked
end
c = c + 1
@ -257,10 +349,7 @@ function mesecon:connected_to_pw_src(pos, checked)
local rules = mesecon:conductor_get_rules(node)
for _, rule in ipairs(rules) do
local np = {}
np.x = pos.x + rule.x
np.y = pos.y + rule.y
np.z = pos.z + rule.z
local np = mesecon:addPosRule(pos, rule)
if mesecon:rules_link(pos, np) then
connected, checked = mesecon:connected_to_pw_src(np, checked)
if connected then
@ -272,9 +361,6 @@ function mesecon:connected_to_pw_src(pos, checked)
end
function mesecon:rules_link(output, input, dug_outputrules) --output/input are positions (outputrules optional, used if node has been dug)
local k = 1
local l = 1
local outputnode = minetest.env:get_node(output)
local inputnode = minetest.env:get_node(input)
@ -300,15 +386,10 @@ function mesecon:rules_link(output, input, dug_outputrules) --output/input are p
end
for k, outputrule in ipairs(outputrules) do
if outputrule.x + output.x == input.x
and outputrule.y + output.y == input.y
and outputrule.z + output.z == input.z then -- Check if output sends to input
l = 1
for k, inputrule in ipairs(inputrules) do
if inputrule.x + input.x == output.x
and inputrule.y + input.y == output.y
and inputrule.z + input.z == output.z then --Check if input accepts from output
for _, outputrule in ipairs(outputrules) do
if mesecon:cmpPos(mesecon:addPosRule(output, outputrule), input) then -- Check if output sends to input
for _, inputrule in ipairs(inputrules) do
if mesecon:cmpPos(mesecon:addPosRule(input, inputrule), output) then --Check if input accepts from output
return true
end
end
@ -339,11 +420,8 @@ function mesecon:is_powered_by_conductor(pos)
return false
end
for i, rule in ipairs(rules) do
local con_pos = {
x = pos.x + rule.x,
y = pos.y + rule.y,
z = pos.z + rule.z}
for _, rule in ipairs(rules) do
local con_pos = mesecon:addPosRule(pos, rule)
con_node = minetest.env:get_node(con_pos)
@ -373,11 +451,8 @@ function mesecon:is_powered_by_receptor(pos)
return false
end
for i, rule in ipairs(rules) do
local rcpt_pos = {
x = pos.x + rule.x,
y = pos.y + rule.y,
z = pos.z + rule.z}
for _, rule in ipairs(rules) do
local rcpt_pos = mesecon:addPosRule(pos, rule)
rcpt_node = minetest.env:get_node(rcpt_pos)
@ -401,10 +476,6 @@ function mesecon:updatenode(pos)
end
end
function compare_pos(pos1, pos2)
return pos1.x == pos2.x and pos1.y == pos2.y and pos1.z == pos2.z
end
--Rules rotation Functions:
function mesecon:rotate_rules_right(rules)
local nr={};

47
mesecons/legacy.lua
View File

@ -1,3 +1,5 @@
--very old:
function mesecon:add_receptor_node(name, rules, get_rules)
if get_rules==nil and rules==nil then
rules=mesecon:get_rules("default")
@ -11,3 +13,48 @@ function mesecon:add_receptor_node_off(name, rules, get_rules)
end
table.insert(mesecon.receptors, {offstate = name, rules = rules, get_rules = get_rules})
end
--old:
function mesecon:register_receptor(onstate, offstate, rules, get_rules)
if get_rules == nil and rules == nil then
rules=mesecon:get_rules("default")
end
table.insert(mesecon.receptors,
{onstate = onstate,
offstate = offstate,
rules = input_rules,
get_rules = get_rules})
end
function mesecon:register_effector(onstate, offstate, input_rules, get_input_rules)
if get_input_rules==nil and input_rules==nil then
rules=mesecon:get_rules("default")
end
table.insert(mesecon.effectors,
{onstate = onstate,
offstate = offstate,
input_rules = input_rules,
get_input_rules = get_input_rules})
end
function mesecon:register_on_signal_on(action)
table.insert(mesecon.actions_on, action)
end
function mesecon:register_on_signal_off(action)
table.insert(mesecon.actions_off, action)
end
function mesecon:register_on_signal_change(action)
table.insert(mesecon.actions_change, action)
end
function mesecon:register_conductor (onstate, offstate, rules, get_rules)
if rules == nil then
rules = mesecon:get_rules("default")
end
table.insert(mesecon.conductors, {onstate = onstate, offstate = offstate, rules = rules, get_rules = get_rules})
end
mesecon:add_rules("default", mesecon.rules.default)

39
mesecons/presets.lua Normal file
View File

@ -0,0 +1,39 @@
mesecon.rules = {}
mesecon.state = {}
mesecon.rules.default =
{{x=0, y=0, z=-1},
{x=1, y=0, z=0},
{x=-1, y=0, z=0},
{x=0, y=0, z=1},
{x=1, y=1, z=0},
{x=1, y=-1, z=0},
{x=-1, y=1, z=0},
{x=-1, y=-1, z=0},
{x=0, y=1, z=1},
{x=0, y=-1, z=1},
{x=0, y=1, z=-1},
{x=0, y=-1, z=-1}}
mesecon.rules.buttonlike =
{{x = 1, y = 0, z = 0},
{x = 1, y = 1, z = 0},
{x = 1, y =-1, z = 0},
{x = 1, y =-1, z = 1},
{x = 1, y =-1, z =-1},
{x = 2, y = 0, z = 0}}
mesecon.rules.buttonlike_get = function(node)
local rules = mesecon.rules.buttonlike
if node.param2 == 2 then
rules=mesecon:rotate_rules_left(rules)
elseif node.param2 == 3 then
rules=mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
elseif node.param2 == 0 then
rules=mesecon:rotate_rules_right(rules)
end
return rules
end
mesecon.state.on = "on"
mesecon.state.off = "off"

1
mesecons/settings.lua
View File

@ -2,3 +2,4 @@
BLINKY_PLANT_INTERVAL = 3
NEW_STYLE_WIRES = true -- true = new nodebox wires, false = old raillike wires
PRESSURE_PLATE_INTERVAL = 0.1
OBJECT_DETECTOR_RADIUS = 6

15
mesecons/util.lua Normal file
View File

@ -0,0 +1,15 @@
function mesecon:swap_node(pos, name)
local node = minetest.env:get_node(pos)
local data = minetest.env:get_meta(pos):to_table()
node.name = name
minetest.env:add_node(pos, node)
minetest.env:get_meta(pos):from_table(data)
end
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)
return (p1.x == p2.x and p1.y == p2.y and p1.z == p2.z)
end

85
mesecons/wires.lua
View File

@ -41,7 +41,6 @@ else -- NEW STYLE WIRES
box_center = {-1/16, -.5, -1/16, 1/16, -.5+1/16, 1/16}
box_bump1 = { -2/16, -8/16, -2/16, 2/16, -13/32, 2/16 }
box_bump2 = { -3/32, -13/32, -3/32, 3/32, -12/32, 3/32 }
box_xp = {1/16, -.5, -1/16, 8/16, -.5+1/16, 1/16}
box_zp = {-1/16, -.5, 1/16, 1/16, -.5+1/16, 8/16}
@ -69,10 +68,10 @@ for zmy=0, 1 do
tostring(xpy)..tostring(zpy)..tostring(xmy)..tostring(zmy)
if nodeid == "00000000" then
groups = {dig_immediate = 3, mesecon = 2, mesecon_conductor_craftable=1}
groups = {dig_immediate = 3, mesecon_conductor_craftable=1}
wiredesc = "Mesecon"
else
groups = {dig_immediate = 3, mesecon = 2, not_in_creative_inventory = 1}
groups = {dig_immediate = 3, not_in_creative_inventory = 1}
wiredesc = "Mesecons Wire (ID: "..nodeid..")"
end
@ -90,7 +89,6 @@ for zmy=0, 1 do
if adjx and adjz and (xp + zp + xm + zm > 2) then
table.insert(nodebox, box_bump1)
table.insert(nodebox, box_bump2)
tiles_off = {
"wires_bump_off.png",
"wires_bump_off.png",
@ -153,7 +151,11 @@ for zmy=0, 1 do
groups = groups,
walkable = false,
stack_max = 99,
drop = "mesecons:wire_00000000_off"
drop = "mesecons:wire_00000000_off",
mesecons = {conductor={
state = mesecon.state.off,
onstate = "mesecons:wire_"..nodeid.."_on"
}}
})
minetest.register_node("mesecons:wire_"..nodeid.."_on", {
@ -174,9 +176,12 @@ for zmy=0, 1 do
groups = {dig_immediate = 3, mesecon = 2, not_in_creative_inventory = 1},
walkable = false,
stack_max = 99,
drop = "mesecons:wire_00000000_off"
drop = "mesecons:wire_00000000_off",
mesecons = {conductor={
state = mesecon.state.on,
offstate = "mesecons:wire_"..nodeid.."_off"
}}
})
mesecon:register_conductor("mesecons:wire_"..nodeid.."_on", "mesecons:wire_"..nodeid.."_off")
end
end
end
@ -186,17 +191,15 @@ end
end
end
minetest.register_on_placenode(function(pos, node)
if minetest.get_item_group(node.name, "mesecon") > 1 then
local update_on_place_dig = function (pos, node)
if minetest.registered_nodes[node.name]
and minetest.registered_nodes[node.name].mesecons then
mesecon:update_autoconnect(pos)
end
end)
end
minetest.register_on_dignode(function(pos, node)
if minetest.get_item_group(node.name, "mesecon") > 1 then
mesecon:update_autoconnect(pos)
end
end)
minetest.register_on_placenode(update_on_place_dig)
minetest.register_on_dignode(update_on_place_dig)
function mesecon:update_autoconnect(pos, secondcall, replace_old)
local xppos = {x=pos.x+1, y=pos.y, z=pos.z}
@ -234,48 +237,20 @@ function mesecon:update_autoconnect(pos, secondcall, replace_old)
nodename = minetest.env:get_node(pos).name
if string.find(nodename, "mesecons:wire_") == nil and not replace_old then return nil end
if mesecon:rules_link_bothdir(pos, xppos) then xp = 1 else xp = 0 end
if mesecon:rules_link_bothdir(pos, xmpos) then xm = 1 else xm = 0 end
if mesecon:rules_link_bothdir(pos, zppos) then zp = 1 else zp = 0 end
if mesecon:rules_link_bothdir(pos, zmpos) then zm = 1 else zm = 0 end
--if the groups mesecon == 1 then wires won't connect to it
local zmg = minetest.get_item_group(minetest.env:get_node(zmpos ).name, "mesecon")
local zmymg = minetest.get_item_group(minetest.env:get_node(zmympos).name, "mesecon")
local xmg = minetest.get_item_group(minetest.env:get_node(xmpos ).name, "mesecon")
local xmymg = minetest.get_item_group(minetest.env:get_node(xmympos).name, "mesecon")
local zpg = minetest.get_item_group(minetest.env:get_node(zppos ).name, "mesecon")
local zpymg = minetest.get_item_group(minetest.env:get_node(zpympos).name, "mesecon")
local xpg = minetest.get_item_group(minetest.env:get_node(xppos ).name, "mesecon")
local xpymg = minetest.get_item_group(minetest.env:get_node(xpympos).name, "mesecon")
if mesecon:rules_link_bothdir(pos, xpympos) then xp = 1 end
if mesecon:rules_link_bothdir(pos, xmympos) then xm = 1 end
if mesecon:rules_link_bothdir(pos, zpympos) then zp = 1 end
if mesecon:rules_link_bothdir(pos, zmympos) then zm = 1 end
local xpyg = minetest.get_item_group(minetest.env:get_node(xpypos).name, "mesecon")
local zpyg = minetest.get_item_group(minetest.env:get_node(zpypos).name, "mesecon")
local xmyg = minetest.get_item_group(minetest.env:get_node(xmypos).name, "mesecon")
local zmyg = minetest.get_item_group(minetest.env:get_node(zmypos).name, "mesecon")
if ((zmg == 2) or (zmymg == 2)) == true then zm = 1 else zm = 0 end
if ((xmg == 2) or (xmymg == 2)) == true then xm = 1 else xm = 0 end
if ((zpg == 2) or (zpymg == 2)) == true then zp = 1 else zp = 0 end
if ((xpg == 2) or (xpymg == 2)) == true then xp = 1 else xp = 0 end
if xpyg == 2 then xpy = 1 else xpy = 0 end
if zpyg == 2 then zpy = 1 else zpy = 0 end
if xmyg == 2 then xmy = 1 else xmy = 0 end
if zmyg == 2 then zmy = 1 else zmy = 0 end
-- If group == 3 then the mesecon only connects to input and output ports
if xpg == 3 and mesecon:rules_link_bothdir(pos, xppos) then xp = 1 end
if xmg == 3 and mesecon:rules_link_bothdir(pos, xmpos) then xm = 1 end
if zpg == 3 and mesecon:rules_link_bothdir(pos, zppos) then zp = 1 end
if zmg == 3 and mesecon:rules_link_bothdir(pos, zmpos) then zm = 1 end
if xpymg == 3 and mesecon:rules_link_bothdir(pos, xpympos) then xp = 1 end
if xmymg == 3 and mesecon:rules_link_bothdir(pos, xmympos) then xm = 1 end
if zpymg == 3 and mesecon:rules_link_bothdir(pos, zpympos) then zp = 1 end
if zmymg == 3 and mesecon:rules_link_bothdir(pos, zmympos) then zm = 1 end
if xpyg == 3 then if mesecon:rules_link(pos, xpypos) then xpy = 1 end end
if zpyg == 3 then if mesecon:rules_link(pos, zpypos) then zpy = 1 end end
if xmyg == 3 then if mesecon:rules_link(pos, xmypos) then xmy = 1 end end
if zmyg == 3 then if mesecon:rules_link(pos, zmypos) then zmy = 1 end end
if mesecon:rules_link(pos, xpypos) then xpy = 1 else xpy = 0 end
if mesecon:rules_link(pos, zpypos) then zpy = 1 else zpy = 0 end
if mesecon:rules_link(pos, xmypos) then xmy = 1 else xmy = 0 end
if mesecon:rules_link(pos, zmypos) then zmy = 1 else zmy = 0 end
-- Backward compatibility
if replace_old then

9
mesecons_blinkyplant/init.lua
View File

@ -13,6 +13,9 @@ minetest.register_node("mesecons_blinkyplant:blinky_plant_off", {
type = "fixed",
fixed = {-0.1, -0.5, -0.1, 0.1, -0.5+0.6, 0.1},
},
mesecons = {receptor = {
state = mesecon.state.off
}}
})
minetest.register_node("mesecons_blinkyplant:blinky_plant_on", {
@ -30,6 +33,9 @@ minetest.register_node("mesecons_blinkyplant:blinky_plant_on", {
type = "fixed",
fixed = {-0.1, -0.5, -0.1, 0.1, -0.5+0.6, 0.1},
},
mesecons = {receptor = {
state = mesecon.state.on
}}
})
minetest.register_craft({
@ -64,6 +70,3 @@ minetest.register_abm({
mesecon:receptor_off(pos)
end,
})
mesecon:add_receptor_node("mesecons_blinkyplant:blinky_plant_on")
mesecon:add_receptor_node_off("mesecons_blinkyplant:blinky_plant_off")

117
mesecons_button/init.lua
View File

@ -1,7 +1,19 @@
-- WALL BUTTON
-- A button that when pressed emits power for 1 second
-- and then turns off again
mesecon.button_turnoff = function (pos)
local node = minetest.env:get_node(pos)
if node.name=="mesecons_button:button_on" then --has not been dug
mesecon:swap_node(pos, "mesecons_button:button_off")
local rules = mesecon.rules.buttonlike_get(node)
mesecon:receptor_off(pos, rules)
end
end
minetest.register_node("mesecons_button:button_off", {
drawtype = "nodebox",
tiles = {
drawtype = "nodebox",
tiles = {
"jeija_wall_button_sides.png",
"jeija_wall_button_sides.png",
"jeija_wall_button_sides.png",
@ -9,25 +21,35 @@ minetest.register_node("mesecons_button:button_off", {
"jeija_wall_button_sides.png",
"jeija_wall_button_off.png"
},
paramtype = "light",
paramtype2 = "facedir",
legacy_wallmounted = true,
walkable = false,
sunlight_propagates = true,
selection_box = {
type = "fixed",
fixed = { -6/16, -6/16, 5/16, 6/16, 6/16, 8/16 }
},
node_box = {
type = "fixed",
fixed = {
paramtype = "light",
paramtype2 = "facedir",
legacy_wallmounted = true,
walkable = false,
sunlight_propagates = true,
selection_box = {
type = "fixed",
fixed = { -6/16, -6/16, 5/16, 6/16, 6/16, 8/16 }
},
node_box = {
type = "fixed",
fixed = {
{ -6/16, -6/16, 6/16, 6/16, 6/16, 8/16 }, -- the thin plate behind the button
{ -4/16, -2/16, 4/16, 4/16, 2/16, 6/16 } -- the button itself
}
},
groups = {dig_immediate=2, mesecon = 3, mesecon_needs_receiver = 1},
description = "Button",
},
groups = {dig_immediate=2, mesecon_needs_receiver = 1},
description = "Button",
on_punch = function (pos, node)
mesecon:swap_node(pos, "mesecons_button:button_on")
mesecon:receptor_on(pos, mesecon.rules.buttonlike_get(node))
minetest.after(1, mesecon.button_turnoff, pos)
end,
mesecons = {receptor = {
state = mesecon.state.off,
rules = mesecon.rules.buttonlike_get
}}
})
minetest.register_node("mesecons_button:button_on", {
drawtype = "nodebox",
tiles = {
@ -44,68 +66,29 @@ minetest.register_node("mesecons_button:button_on", {
walkable = false,
light_source = LIGHT_MAX-7,
sunlight_propagates = true,
selection_box = {
type = "fixed",
fixed = { -6/16, -6/16, 5/16, 6/16, 6/16, 8/16 }
},
node_box = {
type = "fixed",
selection_box = {
type = "fixed",
fixed = { -6/16, -6/16, 5/16, 6/16, 6/16, 8/16 }
},
node_box = {
type = "fixed",
fixed = {
{ -6/16, -6/16, 6/16, 6/16, 6/16, 8/16 },
{ -4/16, -2/16, 11/32, 4/16, 2/16, 6/16 }
}
},
groups = {dig_immediate=2, not_in_creative_inventory=1, mesecon = 3, mesecon_needs_receiver = 1},
groups = {dig_immediate=2, not_in_creative_inventory=1, mesecon_needs_receiver = 1},
drop = 'mesecons_button:button_off',
description = "Button",
mesecons = {receptor = {
state = mesecon.state.on,
rules = mesecon.rules.buttonlike_get
}}
})
minetest.register_on_punchnode(function(pos, node, puncher)
if node.name == "mesecons_button:button_off" then
minetest.env:add_node(pos, {name="mesecons_button:button_on",param2=node.param2})
local rules=mesecon.button_get_rules(node.param2)
mesecon:receptor_on(pos, rules)
minetest.after(1, mesecon.button_turnoff, {pos=pos, param2=node.param2})
end
end)
mesecon.button_turnoff = function (params)
if minetest.env:get_node(params.pos).name=="mesecons_button:button_on" then
minetest.env:add_node(params.pos, {name="mesecons_button:button_off", param2=params.param2})
local rules=mesecon.button_get_rules(params.param2)
mesecon:receptor_off(params.pos, rules)
end
end
mesecon.button_get_rules = function(param2)
local rules=mesecon:get_rules("button")
if param2 == 2 then
rules=mesecon:rotate_rules_left(rules)
end
if param2 == 3 then
rules=mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
end
if param2 == 0 then
rules=mesecon:rotate_rules_right(rules)
end
return rules
end
minetest.register_craft({
output = '"mesecons_button:button_off" 2',
recipe = {
{'"group:mesecon_conductor_craftable"','"default:stone"'},
}
})
mesecon:add_rules("button", {
{x = 1, y = 0, z = 0},
{x = 1, y = 1, z = 0},
{x = 1, y =-1, z = 0},
{x = 1, y =-1, z = 1},
{x = 1, y =-1, z =-1},
{x = 2, y = 0, z = 0},})
mesecon:add_receptor_node_off("mesecons_button:button_off", nil, mesecon.button_get_rules)
mesecon:add_receptor_node("mesecons_button:button_on", nil, mesecon.button_get_rules)

84
mesecons_commandblock/init.lua
View File

@ -87,50 +87,12 @@ local resolve_player = function(name, pos)
return name
end
minetest.register_node("mesecons_commandblock:commandblock_off", {
description = "Command Block",
tiles = {"jeija_commandblock_off.png"},
inventory_image = minetest.inventorycube("jeija_commandblock_off.png"),
groups = {cracky=2, mesecon_effector_off=1, mesecon=2},
on_construct = construct,
after_place_node = after_place,
on_receive_fields = receive_fields,
can_dig = function(pos,player)
local owner = minetest.env:get_meta(pos):get_string("owner")
return owner == "" or owner == player:get_player_name()
end,
})
minetest.register_node("mesecons_commandblock:commandblock_on", {
tiles = {"jeija_commandblock_on.png"},
groups = {cracky=2, mesecon_effector_on=1, mesecon=2, not_in_creative_inventory=1},
light_source = 10,
drop = "mesecons_commandblock:commandblock_off",
on_construct = construct,
after_place_node = after_place,
on_receive_fields = receive_fields,
can_dig = function(pos,player)
local owner = minetest.env:get_meta(pos):get_string("owner")
return owner == "" or owner == player:get_player_name()
end,
})
mesecon:register_effector("mesecons_commandblock:commandblock_on", "mesecons_commandblock:commandblock_off")
local swap_node = function(pos, name)
local node = minetest.env:get_node(pos)
local data = minetest.env:get_meta(pos):to_table()
node.name = name
minetest.env:add_node(pos, node)
minetest.env:get_meta(pos):from_table(data)
end
mesecon:register_on_signal_on(function(pos, node)
local commandblock_action_on = function(pos, node)
if node.name ~= "mesecons_commandblock:commandblock_off" then
return
end
swap_node(pos, "mesecons_commandblock:commandblock_on")
mesecon:swap_node(pos, "mesecons_commandblock:commandblock_on")
local meta = minetest.env:get_meta(pos)
local command = minetest.chatcommands[meta:get_string("command")]
@ -148,10 +110,44 @@ mesecon:register_on_signal_on(function(pos, node)
end
local player = resolve_player(meta:get_string("player"), pos)
command.func(player, meta:get_string("param"))
end)
end
mesecon:register_on_signal_off(function(pos, node)
local commandblock_action_off = function(pos, node)
if node.name == "mesecons_commandblock:commandblock_on" then
swap_node(pos, "mesecons_commandblock:commandblock_off")
mesecon:swap_node(pos, "mesecons_commandblock:commandblock_off")
end
end)
end
minetest.register_node("mesecons_commandblock:commandblock_off", {
description = "Command Block",
tiles = {"jeija_commandblock_off.png"},
inventory_image = minetest.inventorycube("jeija_commandblock_off.png"),
groups = {cracky=2, mesecon_effector_off=1},
on_construct = construct,
after_place_node = after_place,
on_receive_fields = receive_fields,
can_dig = function(pos,player)
local owner = minetest.env:get_meta(pos):get_string("owner")
return owner == "" or owner == player:get_player_name()
end,
mesecons = {effector = {
action_on = commandblock_action_on
}}
})
minetest.register_node("mesecons_commandblock:commandblock_on", {
tiles = {"jeija_commandblock_on.png"},
groups = {cracky=2, mesecon_effector_on=1, not_in_creative_inventory=1},
light_source = 10,
drop = "mesecons_commandblock:commandblock_off",
on_construct = construct,
after_place_node = after_place,
on_receive_fields = receive_fields,
can_dig = function(pos,player)
local owner = minetest.env:get_meta(pos):get_string("owner")
return owner == "" or owner == player:get_player_name()
end,
mesecons = {effector = {
action_off = commandblock_action_off
}}
})

174
mesecons_compatibility/init.lua
View File

@ -1,11 +1,165 @@
minetest.after(0,
function ()
if minetest.registered_nodes["doors:door_wood_b_1"] then
mesecon:register_effector("doors:door_wood_b_1", "doors:door_wood_b_2")
mesecon:register_on_signal_change(function(pos, node)
if node.name == "doors:door_wood_b_2" or node.name == "doors:door_wood_b_1" then
minetest.registered_nodes[node.name].on_punch(pos, node)
end
end)
doors = {}
-- Registers a door - REDEFINITION ONLY | DOORS MOD MUST HAVE BEEN LOADED BEFORE
-- name: The name of the door
-- def: a table with the folowing fields:
-- description
-- inventory_image
-- groups
-- tiles_bottom: the tiles of the bottom part of the door {front, side}
-- tiles_top: the tiles of the bottom part of the door {front, side}
-- If the following fields are not defined the default values are used
-- node_box_bottom
-- node_box_top
-- selection_box_bottom
-- selection_box_top
-- only_placer_can_open: if true only the player who placed the door can
-- open it
function doors:register_door(name, def)
def.groups.not_in_creative_inventory = 1
local box = {{-0.5, -0.5, -0.5, 0.5, 0.5, -0.5+1.5/16}}
if not def.node_box_bottom then
def.node_box_bottom = box
end
end)
if not def.node_box_top then
def.node_box_top = box
end
if not def.selection_box_bottom then
def.selection_box_bottom= box
end
if not def.selection_box_top then
def.selection_box_top = box
end
local tt = def.tiles_top
local tb = def.tiles_bottom
local function after_dig_node(pos, name)
if minetest.env:get_node(pos).name == name then
minetest.env:remove_node(pos)
end
end
local function on_punch(pos, dir, check_name, replace, replace_dir, params)
pos.y = pos.y+dir
if not minetest.env:get_node(pos).name == check_name then
return
end
local p2 = minetest.env:get_node(pos).param2
p2 = params[p2+1]
local meta = minetest.env:get_meta(pos):to_table()
minetest.env:set_node(pos, {name=replace_dir, param2=p2})
minetest.env:get_meta(pos):from_table(meta)
pos.y = pos.y-dir
meta = minetest.env:get_meta(pos):to_table()
minetest.env:set_node(pos, {name=replace, param2=p2})
minetest.env:get_meta(pos):from_table(meta)
end
local function on_mesecons_signal_open (pos, node)
on_punch(pos, 1, name.."_t_1", name.."_b_2", name.."_t_2", {1,2,3,0})
end
local function on_mesecons_signal_close (pos, node)
on_punch(pos, 1, name.."_t_2", name.."_b_1", name.."_t_1", {3,0,1,2})
end
local function check_player_priv(pos, player)
if not def.only_placer_can_open then
return true
end
local meta = minetest.env:get_meta(pos)
local pn = player:get_player_name()
return meta:get_string("doors_owner") == pn
end
minetest.register_node(":"..name.."_b_1", {
tiles = {tb[2], tb[2], tb[2], tb[2], tb[1], tb[1].."^[transformfx"},
paramtype = "light",
paramtype2 = "facedir",
drop = name,
drawtype = "nodebox",
node_box = {
type = "fixed",
fixed = def.node_box_bottom
},
selection_box = {
type = "fixed",
fixed = def.selection_box_bottom
},
groups = def.groups,
after_dig_node = function(pos, oldnode, oldmetadata, digger)
pos.y = pos.y+1
after_dig_node(pos, name.."_t_1")
end,
on_punch = function(pos, node, puncher)
if check_player_priv(pos, puncher) then
on_punch(pos, 1, name.."_t_1", name.."_b_2", name.."_t_2", {1,2,3,0})
end
end,
mesecons = {effector = {
action_on = on_mesecons_signal_open
}},
can_dig = check_player_priv,
})
minetest.register_node(":"..name.."_b_2", {
tiles = {tb[2], tb[2], tb[2], tb[2], tb[1].."^[transformfx", tb[1]},
paramtype = "light",
paramtype2 = "facedir",
drop = name,
drawtype = "nodebox",
node_box = {
type = "fixed",
fixed = def.node_box_bottom
},
selection_box = {
type = "fixed",
fixed = def.selection_box_bottom
},
groups = def.groups,
after_dig_node = function(pos, oldnode, oldmetadata, digger)
pos.y = pos.y+1
after_dig_node(pos, name.."_t_2")
end,
on_punch = function(pos, node, puncher)
if check_player_priv(pos, puncher) then
on_punch(pos, 1, name.."_t_2", name.."_b_1", name.."_t_1", {3,0,1,2})
end
end,
mesecons = {effector = {
action_off = on_mesecons_signal_close
}},
can_dig = check_player_priv,
})
end
doors:register_door("doors:door_wood", {
description = "Wooden Door",
inventory_image = "door_wood.png",
groups = {snappy=1,choppy=2,oddly_breakable_by_hand=2,flammable=2,door=1},
tiles_bottom = {"door_wood_b.png", "door_brown.png"},
tiles_top = {"door_wood_a.png", "door_brown.png"},
})
doors:register_door("doors:door_steel", {
description = "Steel Door",
inventory_image = "door_steel.png",
groups = {snappy=1,bendy=2,cracky=1,melty=2,level=2,door=1},
tiles_bottom = {"door_steel_b.png", "door_grey.png"},
tiles_top = {"door_steel_a.png", "door_grey.png"},
only_placer_can_open = true,
})

269
mesecons_delayer/init.lua
View File

@ -1,9 +1,90 @@
-- Function that get the input/output rules of the delayer
local delayer_get_output_rules = function(node)
local rules = {}
if node.param2 == 0 then
table.insert(rules, {x = 1, y = 0, z = 0})
elseif node.param2 == 2 then
table.insert(rules, {x =-1, y = 0, z = 0})
elseif node.param2 == 1 then
table.insert(rules, {x = 0, y = 0, z =-1})
elseif node.param2 == 3 then
table.insert(rules, {x = 0, y = 0, z = 1})
end
return rules
end
local delayer_get_input_rules = function(node)
local rules = {}
if node.param2 == 0 then
table.insert(rules, {x =-1, y = 0, z = 0})
elseif node.param2 == 2 then
table.insert(rules, {x = 1, y = 0, z = 0})
elseif node.param2 == 1 then
table.insert(rules, {x = 0, y = 0, z = 1})
elseif node.param2 == 3 then
table.insert(rules, {x = 0, y = 0, z =-1})
end
return rules
end
-- Functions that are called after the delay time
local delayer_turnon = function(params)
local rules = delayer_get_output_rules(params)
mesecon:receptor_on(params.pos, rules)
end
local delayer_turnoff = function(params)
local rules = delayer_get_output_rules(params)
mesecon:receptor_off(params.pos, rules)
end
local delayer_update = function(pos, node)
if string.find(node.name, "mesecons_delayer:delayer_off")~=nil then
local time = 0
if node.name=="mesecons_delayer:delayer_off_1" then
mesecon:swap_node(pos, "mesecons_delayer:delayer_on_1")
time=0.1
elseif node.name=="mesecons_delayer:delayer_off_2" then
mesecon:swap_node(pos, "mesecons_delayer:delayer_on_2")
time=0.3
elseif node.name=="mesecons_delayer:delayer_off_3" then
mesecon:swap_node(pos, "mesecons_delayer:delayer_on_3")
time=0.5
elseif node.name=="mesecons_delayer:delayer_off_4" then
mesecon:swap_node(pos, "mesecons_delayer:delayer_on_4")
time=1
end
minetest.after(time, delayer_turnon, {pos=pos, param2=node.param2})
end
if string.find(node.name, "mesecons_delayer:delayer_on")~=nil then
local time = 0
if node.name=="mesecons_delayer:delayer_on_1" then
mesecon:swap_node(pos, "mesecons_delayer:delayer_off_1")
time=0.1
elseif node.name=="mesecons_delayer:delayer_on_2" then
mesecon:swap_node(pos, "mesecons_delayer:delayer_off_2")
time=0.3
elseif node.name=="mesecons_delayer:delayer_on_3" then
mesecon:swap_node(pos, "mesecons_delayer:delayer_off_3")
time=0.5
elseif node.name=="mesecons_delayer:delayer_on_4" then
mesecon:swap_node(pos, "mesecons_delayer:delayer_off_4")
time=1
end
minetest.after(time, delayer_turnoff, {pos=pos, param2=node.param2})
end
end
--Actually register the 2 (states) x 4 (delay times) delayers
for i = 1, 4 do
local groups = {}
if i == 1 then
groups = {bendy=2,snappy=1,dig_immediate=2, mesecon = 3}
groups = {bendy=2,snappy=1,dig_immediate=2}
else
groups = {bendy=2,snappy=1,dig_immediate=2, not_in_creative_inventory=1, mesecon = 3}
groups = {bendy=2,snappy=1,dig_immediate=2, not_in_creative_inventory=1}
end
boxes = {{ -6/16, -8/16, -6/16, 6/16, -7/16, 6/16 }, -- the main slab
@ -46,6 +127,29 @@ minetest.register_node("mesecons_delayer:delayer_off_"..tostring(i), {
sunlight_propagates = true,
is_ground_content = true,
drop = 'mesecons_delayer:delayer_off_1',
on_punch = function (pos, node)
if node.name=="mesecons_delayer:delayer_off_1" then
mesecon:swap_node(pos,"mesecons_delayer:delayer_off_2")
elseif node.name=="mesecons_delayer:delayer_off_2" then
mesecon:swap_node(pos,"mesecons_delayer:delayer_off_3")
elseif node.name=="mesecons_delayer:delayer_off_3" then
mesecon:swap_node(pos,"mesecons_delayer:delayer_off_4")
elseif node.name=="mesecons_delayer:delayer_off_4" then
mesecon:swap_node(pos,"mesecons_delayer:delayer_off_1")
end
end,
mesecons = {
receptor =
{
state = mesecon.state.off,
rules = delayer_get_output_rules
},
effector =
{
rules = delayer_get_input_rules,
action_change = delayer_update
}
}
})
@ -69,147 +173,34 @@ minetest.register_node("mesecons_delayer:delayer_on_"..tostring(i), {
type = "fixed",
fixed = boxes
},
groups = {bendy=2,snappy=1,dig_immediate=2, not_in_creative_inventory=1, mesecon = 3},
groups = {bendy = 2, snappy = 1, dig_immediate = 2, not_in_creative_inventory = 1},
paramtype = "light",
paramtype2 = "facedir",
sunlight_propagates = true,
is_ground_content = true,
drop = 'mesecons_delayer:delayer_off_1',
on_punch = function (pos, node)
if node.name=="mesecons_delayer:delayer_on_1" then
mesecon:swap_node(pos,"mesecons_delayer:delayer_on_2")
elseif node.name=="mesecons_delayer:delayer_on_2" then
mesecon:swap_node(pos,"mesecons_delayer:delayer_on_3")
elseif node.name=="mesecons_delayer:delayer_on_3" then
mesecon:swap_node(pos,"mesecons_delayer:delayer_on_4")
elseif node.name=="mesecons_delayer:delayer_on_4" then
mesecon:swap_node(pos,"mesecons_delayer:delayer_on_1")
end
end,
mesecons = {
receptor =
{
state = mesecon.state.on,
rules = delayer_get_output_rules
},
effector =
{
rules = delayer_get_input_rules,
action_change = delayer_update
}
}
})
end
minetest.register_on_punchnode(function (pos, node)
mesecon.delayer_get_output_rules(node.param2)
if node.name=="mesecons_delayer:delayer_off_1" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_off_2", param2=node.param2})
end
if node.name=="mesecons_delayer:delayer_off_2" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_off_3", param2=node.param2})
end
if node.name=="mesecons_delayer:delayer_off_3" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_off_4", param2=node.param2})
end
if node.name=="mesecons_delayer:delayer_off_4" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_off_1", param2=node.param2})
end
end)
minetest.register_on_punchnode(function (pos, node)
mesecon.delayer_get_output_rules(node.param2)
if node.name=="mesecons_delayer:delayer_on_1" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_on_2", param2=node.param2})
end
if node.name=="mesecons_delayer:delayer_on_2" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_on_3", param2=node.param2})
end
if node.name=="mesecons_delayer:delayer_on_3" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_on_4", param2=node.param2})
end
if node.name=="mesecons_delayer:delayer_on_4" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_on_1", param2=node.param2})
end
end)
mesecon.delayer_update = function(pos, node)
if string.find(node.name, "mesecons_delayer:delayer_off")~=nil then
local time = 0
if node.name=="mesecons_delayer:delayer_off_1" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_on_1", param2=node.param2})
time=0.1
end
if node.name=="mesecons_delayer:delayer_off_2" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_on_2", param2=node.param2})
time=0.3
end
if node.name=="mesecons_delayer:delayer_off_3" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_on_3", param2=node.param2})
time=0.5
end
if node.name=="mesecons_delayer:delayer_off_4" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_on_4", param2=node.param2})
time=1
end
minetest.after(time, mesecon.delayer_turnon, {pos=pos, param2=node.param2})
end
if string.find(node.name, "mesecons_delayer:delayer_on")~=nil then
local time = 0
if node.name=="mesecons_delayer:delayer_on_1" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_off_1", param2=node.param2})
time=0.1
end
if node.name=="mesecons_delayer:delayer_on_2" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_off_2", param2=node.param2})
time=0.3
end
if node.name=="mesecons_delayer:delayer_on_3" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_off_3", param2=node.param2})
time=0.5
end
if node.name=="mesecons_delayer:delayer_on_4" then
minetest.env:add_node(pos, {name="mesecons_delayer:delayer_off_4", param2=node.param2})
time=1
end
minetest.after(time, mesecon.delayer_turnoff, {pos=pos, param2=node.param2})
end
end
mesecon:register_on_signal_change(mesecon.delayer_update)
mesecon.delayer_turnon=function(params)
local rules = mesecon.delayer_get_output_rules(params.param2)
mesecon:receptor_on(params.pos, rules)
end
mesecon.delayer_turnoff=function(params)
local rules = mesecon.delayer_get_output_rules(params.param2)
mesecon:receptor_off(params.pos, rules)
end
mesecon.delayer_get_output_rules = function(param2)
local rules = {}
if param2 == 0 then
table.insert(rules, {x = 1, y = 0, z = 0})
elseif param2 == 2 then
table.insert(rules, {x =-1, y = 0, z = 0})
elseif param2 == 1 then
table.insert(rules, {x = 0, y = 0, z =-1})
elseif param2 == 3 then
table.insert(rules, {x = 0, y = 0, z = 1})
end
return rules
end
mesecon.delayer_get_input_rules = function(param2)
local rules = {}
if param2 == 0 then
table.insert(rules, {x =-1, y = 0, z = 0})
elseif param2 == 2 then
table.insert(rules, {x = 1, y = 0, z = 0})
elseif param2 == 1 then
table.insert(rules, {x = 0, y = 0, z = 1})
elseif param2 == 3 then
table.insert(rules, {x = 0, y = 0, z =-1})
end
return rules
end
all_rules = {{x = 1, y = 0, z = 0}, {x =-1, y = 0, z = 0}, {x = 0, y = 0, z =-1}, {x = 0, y = 0, z = 1}} --required to check if a newly placed should be turned on
mesecon:add_receptor_node("mesecons_delayer:delayer_on_1", all_rules, mesecon.delayer_get_output_rules)
mesecon:add_receptor_node("mesecons_delayer:delayer_on_2", all_rules, mesecon.delayer_get_output_rules)
mesecon:add_receptor_node("mesecons_delayer:delayer_on_3", all_rules, mesecon.delayer_get_output_rules)
mesecon:add_receptor_node("mesecons_delayer:delayer_on_4", all_rules, mesecon.delayer_get_output_rules)
mesecon:add_receptor_node_off("mesecons_delayer:delayer_off_1", all_rules, mesecon.delayer_get_output_rules)
mesecon:add_receptor_node_off("mesecons_delayer:delayer_off_2", all_rules, mesecon.delayer_get_output_rules)
mesecon:add_receptor_node_off("mesecons_delayer:delayer_off_3", all_rules, mesecon.delayer_get_output_rules)
mesecon:add_receptor_node_off("mesecons_delayer:delayer_off_4", all_rules, mesecon.delayer_get_output_rules)
mesecon:register_effector("mesecons_delayer:delayer_on_1", "mesecons_delayer:delayer_off_1", all_rules, mesecon.delayer_get_input_rules)
mesecon:register_effector("mesecons_delayer:delayer_on_2", "mesecons_delayer:delayer_off_2", all_rules, mesecon.delayer_get_input_rules)
mesecon:register_effector("mesecons_delayer:delayer_on_3", "mesecons_delayer:delayer_off_3", all_rules, mesecon.delayer_get_input_rules)
mesecon:register_effector("mesecons_delayer:delayer_on_4", "mesecons_delayer:delayer_off_4", all_rules, mesecon.delayer_get_input_rules)

29
mesecons_detector/init.lua
View File

@ -1,19 +1,27 @@
--SHORT RANGE DETECTORS
-- Object detector
-- Detects all entities in a certain radius
-- The radius can be specified in mesecons/settings.lua
minetest.register_node("mesecons_detector:object_detector_off", {
tiles = {"default_steel_block.png", "default_steel_block.png", "jeija_object_detector_off.png", "jeija_object_detector_off.png", "jeija_object_detector_off.png", "jeija_object_detector_off.png"},
paramtype = "light",
walkable = true,
groups = {cracky=3, mesecon = 2},
groups = {cracky=3},
description="Player Detector",
mesecons = {receptor = {
state = mesecon.state.off
}}
})
minetest.register_node("mesecons_detector:object_detector_on", {
tiles = {"default_steel_block.png", "default_steel_block.png", "jeija_object_detector_on.png", "jeija_object_detector_on.png", "jeija_object_detector_on.png", "jeija_object_detector_on.png"},
paramtype = "light",
walkable = true,
groups = {cracky=3,not_in_creative_inventory=1, mesecon = 2},
groups = {cracky=3,not_in_creative_inventory=1},
drop = 'mesecons_detector:object_detector_off',
description="Player Detector",
mesecons = {receptor = {
state = mesecon.state.on
}}
})
minetest.register_craft({
@ -30,9 +38,9 @@ minetest.register_abm(
interval = 1.0,
chance = 1,
action = function(pos, node, active_object_count, active_object_count_wider)
local objs = minetest.env:get_objects_inside_radius(pos, 6)
local objs = minetest.env:get_objects_inside_radius(pos, OBJECT_DETECTOR_RADIUS)
for k, obj in pairs(objs) do
if obj:get_entity_name()~="mesecons_pistons:piston_pusher_sticky" and obj:get_entity_name()~="mesecons_pistons:piston_pusher_normal" and obj:get_player_name()~=nil then -- Detected object is not piston pusher - will be changed if every entity has a type (like entity_type=mob)
if obj:get_entity_name()~="mesecons_pistons:piston_pusher_sticky" and obj:get_entity_name()~="mesecons_pistons:piston_pusher_normal" and obj:get_player_name()~=nil then
if minetest.env:get_node({x=pos.x, y=pos.y-1, z=pos.z}).name=="default:sign_wall" then
if obj:get_player_name()~=minetest.env:get_meta({x=pos.x, y=pos.y-1, z=pos.z}):get_string("text") then
return
@ -40,7 +48,7 @@ minetest.register_abm(
end
local objpos=obj:getpos()
minetest.env:add_node(pos, {name="mesecons_detector:object_detector_on"})
mesecon:receptor_on(pos, mesecon:get_rules("pressureplate"))
mesecon:receptor_on(pos)
end
end
end,
@ -51,7 +59,7 @@ minetest.register_abm(
interval = 1.0,
chance = 1,
action = function(pos, node, active_object_count, active_object_count_wider)
local objs = minetest.env:get_objects_inside_radius(pos, 6)
local objs = minetest.env:get_objects_inside_radius(pos, OBJECT_DETECTOR_RADIUS)
local objectfound=0
for k, obj in pairs(objs) do
if obj:get_entity_name()~="mesecons_pistons:piston_pusher_sticky" and obj:get_entity_name()~="mesecons_pistons:piston_pusher_normal" and obj~=nil
@ -68,10 +76,7 @@ minetest.register_abm(
end
if objectfound==0 then
minetest.env:add_node(pos, {name="mesecons_detector:object_detector_off"})
mesecon:receptor_off(pos, mesecon:get_rules("pressureplate"))
mesecon:receptor_off(pos)
end
end,
})
mesecon:add_receptor_node("mesecons_detector:object_detector_on", mesecon:get_rules("pressureplate"))
mesecon:add_receptor_node_off("mesecons_detector:object_detector_off", mesecon:get_rules("pressureplate"))

4
mesecons_dev/README
View File

@ -1,4 +0,0 @@
Please note:
The mesecons modules in here have been disabled for various reasons:
They are old and deprecated, are not needed anymore or are buggy atm.
You can create a module out of them, but it is not recommended to use any of them.

1
mesecons_dev/init.lua
View File

@ -1 +0,0 @@
--read README

2
mesecons_dev/mesecons_wireless/depends.txt
View File

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

313
mesecons_dev/mesecons_wireless/init.lua
View File

@ -1,313 +0,0 @@
--COMMON WIRELESS FUNCTIONS
mesecon.wireless_receivers={}
function mesecon:read_wlre_from_file()
print "[MESEcons] Reading Mesecon Data..."
mesecon_file=io.open(minetest.get_modpath("jeija").."/mesecon_data", "r")
if mesecon_file==nil then return end
local row=mesecon_file:read()
local i=1
while row~=nil do
mesecon.wireless_receivers[i]={}
mesecon.wireless_receivers[i].pos={}
mesecon.wireless_receivers[i].pos.x=tonumber(mesecon_file:read())
mesecon.wireless_receivers[i].pos.y=tonumber(mesecon_file:read())
mesecon.wireless_receivers[i].pos.z=tonumber(mesecon_file:read())
mesecon.wireless_receivers[i].channel=mesecon_file:read()
mesecon.wireless_receivers[i].requested_state=tonumber(mesecon_file:read())
mesecon.wireless_receivers[i].inverting=tonumber(mesecon_file:read())
i=i+1
row=mesecon_file:read()
end
mesecon_file:close()
print "[MESEcons] Finished Reading Mesecon Data..."
end
function mesecon:register_wireless_receiver(pos, inverting)
local i = 1
repeat
if mesecon.wireless_receivers[i]==nil then break end
i=i+1
until false
local node_under_pos={}
node_under_pos.x=pos.x
node_under_pos.y=pos.y
node_under_pos.z=pos.z
node_under_pos.y=node_under_pos.y-1
local node_under=minetest.env:get_node(node_under_pos)
mesecon.wireless_receivers[i]={}
mesecon.wireless_receivers[i].pos={}
mesecon.wireless_receivers[i].pos.x=pos.x
mesecon.wireless_receivers[i].pos.y=pos.y
mesecon.wireless_receivers[i].pos.z=pos.z
mesecon.wireless_receivers[i].channel=node_under.name
mesecon.wireless_receivers[i].requested_state=0
mesecon.wireless_receivers[i].inverting=inverting
end
function mesecon:remove_wireless_receiver(pos)
local i = 1
while mesecon.wireless_receivers[i]~=nil do
if mesecon.wireless_receivers[i].pos.x==pos.x and
mesecon.wireless_receivers[i].pos.y==pos.y and
mesecon.wireless_receivers[i].pos.z==pos.z then
mesecon.wireless_receivers[i]=nil
break
end
i=i+1
end
end
function mesecon:set_wlre_channel(pos, channel)
--local i = 1
--while mesecon.wireless_receivers[i]~=nil do
-- if tonumber(mesecon.wireless_receivers[i].pos.x)==tonumber(pos.x) and
-- tonumber(mesecon.wireless_receivers[i].pos.y)==tonumber(pos.y) and
-- tonumber(mesecon.wireless_receivers[i].pos.z)==tonumber(pos.z) then
-- mesecon.wireless_receivers[i].channel=channel
-- break
-- end
-- i=i+1
--end
local wlre=mesecon:get_wlre(pos)
if wlre~=nil then
wlre.channel=channel
end
end
function mesecon:get_wlre(pos)
local i=1
while mesecon.wireless_receivers[i]~=nil do
if mesecon.wireless_receivers[i].pos.x==pos.x and
mesecon.wireless_receivers[i].pos.y==pos.y and
mesecon.wireless_receivers[i].pos.z==pos.z then
return mesecon.wireless_receivers[i]
end
i=i+1
end
end
minetest.register_on_placenode(function(pos, newnode, placer)
pos.y=pos.y+1
if minetest.env:get_node(pos).name == "mesecons_wireless:wireless_receiver_off" or
minetest.env:get_node(pos).name == "mesecons_wireless:wireless_receiver_on" or
minetest.env:get_node(pos).name == "mesecons_wireless:wireless_inverter_off" or
minetest.env:get_node(pos).name == "mesecons_wireless:wireless_inverter_on" then
mesecon:set_wlre_channel(pos, newnode.name)
end
end)
minetest.register_on_dignode(
function(pos, oldnode, digger)
local channel
pos.y=pos.y+1
if minetest.env:get_node(pos).name == "mesecons_wireless:wireless_receiver_on" or
minetest.env:get_node(pos).name == "mesecons_wireless:wireless_receiver_off" or
minetest.env:get_node(pos).name == "mesecons_wireless:wireless_inverter_on" or
minetest.env:get_node(pos).name == "mesecons_wireless:wireless_inverter_off" then
mesecon:set_wlre_channel(pos, "air")
end
end
)
minetest.register_abm(
{nodenames = {"mesecons_wireless:wireless_receiver_on", "mesecons_wireless:wireless_receiver_off",
"mesecons_wireless:wireless_inverter_on", "mesecons_wireless:wireless_inverter_off"},
interval = 1.0,
chance = 1,
action = function(pos, node, active_object_count, active_object_count_wider)
local wlre=mesecon:get_wlre(pos)
if (wlre==nil) then return end
if node.name=="mesecons_wireless:wireless_receiver_on" and wlre.requested_state==0 then
minetest.env:add_node(pos, {name="mesecons_wireless:wireless_receiver_off"})
mesecon:receptor_off(pos)
end
if node.name=="mesecons_wireless:wireless_receiver_off" and wlre.requested_state==1 then
minetest.env:add_node(pos, {name="mesecons_wireless:wireless_receiver_on"})
mesecon:receptor_on(pos)
end
if node.name=="mesecons_wireless:wireless_inverter_off" and wlre.requested_state==0 and wlre.inverting==1 then
minetest.env:add_node(pos, {name="mesecons_wireless:wireless_inverter_on"})
mesecon:receptor_on(pos)
end
if node.name=="mesecons_wireless:wireless_inverter_on" and wlre.requested_state==1 and wlre.inverting==1 then
minetest.env:add_node(pos, {name="mesecons_wireless:wireless_inverter_off"})
mesecon:receptor_off(pos)
end
end,
})
--WIRELESS RECEIVER
minetest.register_node("mesecons_wireless:wireless_receiver_off", {
tile_images = {"jeija_wireless_receiver_tb_off.png", "jeija_wireless_receiver_tb_off.png", "jeija_wireless_receiver_off.png", "jeija_wireless_receiver_off.png", "jeija_wireless_receiver_off.png", "jeija_wireless_receiver_off.png"},
inventory_image = minetest.inventorycube("jeija_wireless_receiver_off.png"),
groups = {choppy=2},
description="Wireless Receiver",
after_place_node = function(pos)
mesecon:register_wireless_receiver(pos, 0)
end,
after_dig_node = function(pos)
mesecon:remove_wireless_receiver(pos)
mesecon:receptor_off(pos)
end
})
minetest.register_node("mesecons_wireless:wireless_receiver_on", {
tile_images = {"jeija_wireless_receiver_tb_on.png", "jeija_wireless_receiver_tb_on.png", "jeija_wireless_receiver_on.png", "jeija_wireless_receiver_on.png", "jeija_wireless_receiver_on.png", "jeija_wireless_receiver_on.png"},
inventory_image = minetest.inventorycube("jeija_wireless_receiver_on.png"),
groups = {choppy=2},
drop = 'mesecons_wireless:wireless_receiver_off',
description="Wireless Receiver",
after_place_node = function(pos)
mesecon:register_wireless_receiver(pos, 0)
end,
after_dig_node = function(pos)
mesecon:remove_wireless_receiver(pos)
end
})
minetest.register_craft({
output = '"mesecons_wireless:wireless_receiver_off" 2',
recipe = {
{'', "group:mesecon_conductor_craftable", ''},
{'', "group:mesecon_conductor_craftable", ''},
{'', "mesecons_materials:ic", ''},
}
})
minetest.register_abm( -- SAVE WIRELESS RECEIVERS TO FILE
{nodenames = {"mesecons_wireless:wireless_receiver_off", "mesecons_wireless:wireless_receiver_on", "mesecons_wireless:wireless_inverter_on", "mesecons_wireless:wireless_inverter_off"},
interval = 10,
chance = 1,
action = function(pos, node, active_object_count, active_object_count_wider)
local mesecon_file = io.open(minetest.get_modpath("jeija").."/mesecon_data", "w")
local i=1
while mesecon.wireless_receivers[i]~=nil do
mesecon_file:write("NEXT\n")
mesecon_file:write(mesecon.wireless_receivers[i].pos.x.."\n")
mesecon_file:write(mesecon.wireless_receivers[i].pos.y.."\n")
mesecon_file:write(mesecon.wireless_receivers[i].pos.z.."\n")
mesecon_file:write(mesecon.wireless_receivers[i].channel.."\n")
mesecon_file:write(mesecon.wireless_receivers[i].requested_state.."\n")
mesecon_file:write(mesecon.wireless_receivers[i].inverting.."\n")
i=i+1
end
mesecon_file:close()
end,
})
mesecon:add_receptor_node("mesecons_wireless:wireless_receiver_on")
mesecon:add_receptor_node_off("mesecons_wireless:wireless_receiver_off")
-- WIRELESS INVERTER OFF/ON BELONGS TO THE OUTPUT STATE (ON=INPUT OFF)
minetest.register_node("mesecons_wireless:wireless_inverter_off", {
tile_images = {"jeija_wireless_inverter_tb.png", "jeija_wireless_inverter_tb.png", "jeija_wireless_inverter_off.png", "jeija_wireless_inverter_off.png", "jeija_wireless_inverter_off.png", "jeija_wireless_inverter_off.png"},
inventory_image = minetest.inventorycube("jeija_wireless_inverter_off.png"),
groups = {choppy=2},
drop = 'mesecons_wireless:wireless_inverter_on',
description = "Wireless Inverter",
after_place_node = function(pos)
mesecon:register_wireless_receiver(pos, 1)
mesecon:receptor_on(pos)
end,
after_dig_node = function(pos)
mesecon:remove_wireless_receiver(pos)
end
})
minetest.register_node("mesecons_wireless:wireless_inverter_on", {
tile_images = {"jeija_wireless_inverter_tb.png", "jeija_wireless_inverter_tb.png", "jeija_wireless_inverter_on.png", "jeija_wireless_inverter_on.png", "jeija_wireless_inverter_on.png", "jeija_wireless_inverter_on.png"},
inventory_image = minetest.inventorycube("jeija_wireless_inverter_on.png"),
groups = {choppy=2},
description = "Wireless Inverter",
after_place_node = function(pos)
mesecon:register_wireless_receiver(pos, 1)
mesecon:receptor_on(pos)
end,
after_dig_node = function(pos)
mesecon:remove_wireless_receiver(pos)
mesecon:receptor_off(pos)
end
})
minetest.register_craft({
output = '"mesecons_wireless:wireless_inverter_off" 2',
recipe = {
{'', 'default:steel_ingot', ''},
{'mesecons_materials:ic', 'group:mesecon_conductor_craftable', 'mesecons_materials:ic'},
{'', 'group:mesecon_conductor_craftable', ''},
}
})
mesecon:add_receptor_node("mesecons_wireless:wireless_inverter_on")
mesecon:add_receptor_node_off("mesecons_wireless:wireless_inverter_off")
-- WIRELESS TRANSMITTER
function mesecon:wireless_transmit(channel, senderstate)
local i = 1
while mesecon.wireless_receivers[i]~=nil do
if mesecon.wireless_receivers[i].channel==channel then
if senderstate==1 then
mesecon.wireless_receivers[i].requested_state=1
elseif senderstate==0 then
mesecon.wireless_receivers[i].requested_state=0
end
end
i=i+1
end
end
minetest.register_node("mesecons_wireless:wireless_transmitter_on", {
tile_images = {"jeija_wireless_transmitter_tb.png", "jeija_wireless_transmitter_tb.png", "jeija_wireless_transmitter_on.png", "jeija_wireless_transmitter_on.png", "jeija_wireless_transmitter_on.png", "jeija_wireless_transmitter_on.png"},
inventory_image = minetest.inventorycube("jeija_wireless_transmitter_on.png"),
groups = {choppy=2},
drop = {'"mesecons_wireless:wireless_transmitter_off" 1'},
description="Wireless Transmitter",
})
minetest.register_node("mesecons_wireless:wireless_transmitter_off", {
tile_images = {"jeija_wireless_transmitter_tb.png", "jeija_wireless_transmitter_tb.png", "jeija_wireless_transmitter_off.png", "jeija_wireless_transmitter_off.png", "jeija_wireless_transmitter_off.png", "jeija_wireless_transmitter_off.png"},
inventory_image = minetest.inventorycube("jeija_wireless_transmitter_off.png"),
groups = {choppy=2},
description="Wireless Transmitter",
})
minetest.register_craft({
output = '"mesecons_wireless:wireless_transmitter_off" 2',
recipe = {
{'default:steel_ingot', 'group:mesecon_conductor_craftable', 'default:steel_ingot'},
{'', 'group:mesecon_conductor_craftable', ''},
{'', 'mesecons_materials:ic', ''},
}
})
mesecon:register_on_signal_on(function(pos, node)
if node.name=="mesecons_wireless:wireless_transmitter_off" then
minetest.env:add_node(pos, {name="mesecons_wireless:wireless_transmitter_on"})
local node_under_pos=pos
node_under_pos.y=node_under_pos.y-1
local node_under=minetest.env:get_node(node_under_pos)
mesecon:wireless_transmit(node_under.name, 1)
end
end)
mesecon:register_on_signal_off(function(pos, node)
if node.name=="mesecons_wireless:wireless_transmitter_on" then
minetest.env:add_node(pos, {name="mesecons_wireless:wireless_transmitter_off"})
local node_under_pos=pos
node_under_pos.y=node_under_pos.y-1
local node_under=minetest.env:get_node(node_under_pos)
mesecon:wireless_transmit(node_under.name, 0)
end
end)
mesecon:read_wlre_from_file()

2
mesecons_extrawires/crossing.lua
View File

@ -1,3 +1,5 @@
-- CODE NOT ACTIVE
for x=-1, 1 do for z=-1, 1 do
rules = {}
nodename = "mesecons_extrawires:crossing"

3
mesecons_extrawires/init.lua
View File

@ -1,2 +1,3 @@
dofile(minetest.get_modpath("mesecons_extrawires").."/crossing.lua");
-- dofile(minetest.get_modpath("mesecons_extrawires").."/crossing.lua");
-- The crossing code is not active right now because it is hard to maintain
dofile(minetest.get_modpath("mesecons_extrawires").."/tjunction.lua");

54
mesecons_extrawires/tjunction.lua
View File

@ -9,6 +9,22 @@ local tjunction_selectionbox = {
fixed = { -16/32-0.001, -18/32, -16/32, 16/32+0.001, -12/32, 7/32 },
}
local tjunction_get_rules = function (node)
local rules =
{{x = 1, y = 0, z = 0},
{x =-1, y = 0, z = 0},
{x = 0, y = 0, z = -1}}
if node.param2 == 1 then
rules = mesecon:rotate_rules_left(rules)
elseif node.param2 == 2 then
rules = mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
elseif node.param2 == 3 then
rules = mesecon:rotate_rules_right(rules)
end
return rules
end
minetest.register_node("mesecons_extrawires:tjunction_on", {
drawtype = "nodebox",
tiles = {
@ -27,7 +43,12 @@ minetest.register_node("mesecons_extrawires:tjunction_on", {
node_box = tjunction_nodebox,
groups = {dig_immediate = 3, mesecon = 3, mesecon_conductor_craftable=1, not_in_creative_inventory = 1},
drop = "mesecons_insulated:insulated_off",
mesecons = {conductor =
{
state = mesecon.state.on,
rules = tjunction_get_rules,
offstate = "mesecons_extrawires:tjunction_off"
}}
})
minetest.register_node("mesecons_extrawires:tjunction_off", {
@ -48,6 +69,12 @@ minetest.register_node("mesecons_extrawires:tjunction_off", {
selection_box = tjunction_selectionbox,
node_box = tjunction_nodebox,
groups = {dig_immediate = 3, mesecon = 3, mesecon_conductor_craftable=1},
mesecons = {conductor =
{
state = mesecon.state.off,
rules = tjunction_get_rules,
onstate = "mesecons_extrawires:tjunction_on"
}}
})
minetest.register_craft({
@ -58,28 +85,3 @@ minetest.register_craft({
{"", "mesecons_insulated:insulated_off", ""},
}
})
mesecon:add_rules("tjunction_all", { --all possible rules
{x = 1, y = 0, z = 0},
{x =-1, y = 0, z = 0},
{x = 0, y = 0, z = 1},
{x = 0, y = 0, z =-1},})
mesecon:add_rules("tjunction", {
{x = 1, y = 0, z = 0},
{x =-1, y = 0, z = 0},
{x = 0, y = 0, z = -1},})
function tjunction_get_rules(param2)
local rules = mesecon:get_rules("tjunction")
if param2 == 1 then
rules = mesecon:rotate_rules_left(mesecon:get_rules("tjunction"))
elseif param2 == 2 then
rules = mesecon:rotate_rules_right(mesecon:rotate_rules_right(mesecon:get_rules("tjunction")))
elseif param2 == 3 then
rules = mesecon:rotate_rules_right(mesecon:get_rules("tjunction"))
end
return rules
end
mesecon:register_conductor("mesecons_extrawires:tjunction_on", "mesecons_extrawires:tjunction_off", mesecon:get_rules("tjunction_all"), tjunction_get_rules)

261
mesecons_gates/init.lua
View File

@ -1,62 +1,127 @@
outrules = {
{x=1, y=0, z=0},
}
oneinput = {
{x=-1, y=0, z=0},
{x=1, y=0, z=0},
}
twoinputs = {
{x=0, y=0, z=1},
{x=0, y=0, z=-1},
{x=1, y=0, z=0},
}
function get_gate_rules(param2, onlyout, singleinput)
if onlyout then
rules = outrules
else
if singleinput then
rules = oneinput
else
rules = twoinputs
end
end
for rotations=0, param2-1 do
function gate_rotate_rules(node)
for rotations = 0, node.param2 - 1 do
rules = mesecon:rotate_rules_left(rules)
end
return rules
end
function get_gate_rules_one(param2) return get_gate_rules(param2, false, true) end
function get_gate_rules_two(param2) return get_gate_rules(param2, false, false) end
function get_gate_rules_out(param2) return get_gate_rules(param2, true) end
gates = {"diode", "not", "nand", "and", "xor"}
for g in ipairs(gates) do gate = gates[g]
if g < 3 then
get_rules = get_gate_rules_one
else
get_rules = get_gate_rules_two
function gate_get_output_rules(node)
rules = {{x=1, y=0, z=0}}
return gate_rotate_rules(node)
end
function gate_get_input_rules_oneinput(node)
rules = {{x=-1, y=0, z=0}, {x=1, y=0, z=0}}
return gate_rotate_rules(node)
end
function gate_get_input_rules_twoinputs(node)
rules = {
{x=0, y=0, z=1},
{x=0, y=0, z=-1},
{x=1, y=0, z=0}}
return gate_rotate_rules(node)
end
function update_gate(pos)
gate = get_gate(pos)
L = rotate_ports(
yc_get_real_portstates(pos),
minetest.env:get_node(pos).param2
)
if gate == "diode" then
set_gate(pos, L.a)
elseif gate == "not" then
set_gate(pos, not L.a)
elseif gate == "nand" then
set_gate(pos, not(L.b and L.d))
elseif gate == "and" then
set_gate(pos, L.b and L.d)
elseif gate == "xor" then
set_gate(pos, (L.b and not L.d) or (not L.b and L.d))
end
for on=0,1 do
nodename = "mesecons_gates:"..gate
end
function set_gate(pos, on)
gate = get_gate(pos)
local meta = minetest.env:get_meta(pos)
if on ~= gate_state(pos) then
yc_heat(meta)
minetest.after(0.5, yc_cool, meta)
if yc_overheat(meta) then
pop_gate(pos)
else
if on then
mesecon:swap_node(pos, "mesecons_gates:"..gate.."_on")
mesecon:receptor_on(pos,
gate_get_output_rules(minetest.env:get_node(pos)))
else
mesecon:swap_node(pos, "mesecons_gates:"..gate.."_off")
mesecon:receptor_off(pos,
gate_get_output_rules(minetest.env:get_node(pos)))
end
end
end
end
function get_gate(pos)
return minetest.registered_nodes[minetest.env:get_node(pos).name].mesecons_gate
end
function gate_state(pos)
name = minetest.env:get_node(pos).name
return string.find(name, "_on") ~= nil
end
function pop_gate(pos)
gate = get_gate(pos)
minetest.env:remove_node(pos)
minetest.after(0.2, yc_overheat_off, pos)
minetest.env:add_item(pos, "mesecons_gates:"..gate.."_off")
end
function rotate_ports(L, param2)
for rotations=0, param2-1 do
port = L.a
L.a = L.b
L.b = L.c
L.c = L.d
L.d = port
end
return L
end
gates = {
{name = "diode", inputnumber = 1},
{name = "not" , inputnumber = 1},
{name = "nand" , inputnumber = 2},
{name = "and" , inputnumber = 2},
{name = "xor" , inputnumber = 2}}
for i, gate in ipairs(gates) do
if gate.inputnumber == 1 then
get_rules = gate_get_input_rules_oneinput
elseif gate.inputnumber == 2 then
get_rules = gate_get_input_rules_twoinputs
end
for on = 0, 1 do
nodename = "mesecons_gates:"..gate.name
if on == 1 then
onoff = "on"
drop = nodename.."_off"
nodename = nodename.."_"..onoff
description = "You hacker you!"
groups = {dig_immediate=2, not_in_creative_inventory=1, mesecon = 3}
mesecon:add_receptor_node(nodename, get_rules, get_gate_rules_out)
--mesecon:add_receptor_node(nodename, mesecon:get_rules("insulated_all"))
groups = {dig_immediate=2, not_in_creative_inventory=1}
else
onoff = "off"
nodename = nodename.."_"..onoff
description = gate.." Gate"
groups = {dig_immediate=2, mesecon = 3}
--mesecon:add_receptor_node_off(nodename, get_gate_rules_out)
description = gate.name.." Gate"
groups = {dig_immediate=2}
end
tiles = "jeija_microcontroller_bottom.png^"..
"jeija_gate_"..onoff..".png^"..
"jeija_gate_"..gate..".png"
"jeija_gate_"..gate.name..".png"
node_box = {
type = "fixed",
@ -65,6 +130,13 @@ for g in ipairs(gates) do gate = gates[g]
},
}
local mesecon_state
if on == 1 then
mesecon_state = mesecon.state.on
else
mesecon_state = mesecon.state.off
end
minetest.register_node(nodename, {
description = description,
paramtype = "light",
@ -82,103 +154,24 @@ for g in ipairs(gates) do gate = gates[g]
end,
groups = groups,
drop = drop,
mesecons_gate = gate.name,
mesecons =
{
receptor =
{
state = mesecon_state,
rules = gate_get_output_rules
},
effector =
{
rules = get_rules,
action_change = update_gate
}
}
})
mesecon:register_effector(nodename, nodename, all_rules, get_rules)
end
end
function get_gate(pos)
return
string.gsub(
string.gsub(
string.gsub(
minetest.env:get_node(pos).name
, "mesecons_gates:", "") --gate
,"_on", "")
,"_off", "")
end
function gate_state(pos)
name = minetest.env:get_node(pos).name
return string.find(name, "_on") ~= nil
end
function pop_gate(pos)
gate = get_gate(pos)
minetest.env:remove_node(pos)
minetest.after(0.2, yc_overheat_off, pos)
minetest.env:add_item(pos, "mesecons_gates:"..gate.."_off")
end
function set_gate(pos, on)
gate = get_gate(pos)
local meta = minetest.env:get_meta(pos)
if on ~= gate_state(pos) then
yc_heat(meta)
minetest.after(0.5, yc_cool, meta)
if yc_overheat(meta) then
pop_gate(pos)
else
heat = meta:get_int("heat")
if on then
onoff = "_on"
else
onoff = "_off"
end
param2 = minetest.env:get_node(pos).param2
minetest.env:add_node(pos, {
name = "mesecons_gates:"..gate..onoff,
param2 = param2,
})
local meta2 = minetest.env:get_meta(pos)
meta2:set_int("heat", heat)
if on then
mesecon:receptor_on(pos, get_gate_rules(param2, true))
else
mesecon:receptor_off(pos, all_rules)
end
end
end
end
function rotate_ports(L, param2)
for rotations=0, param2-1 do
port = L.a
L.a = L.b
L.b = L.c
L.c = L.d
L.d = port
end
return L
end
function update_gate(pos)
gate = get_gate(pos)
L = rotate_ports(
yc_get_real_portstates(pos),
minetest.env:get_node(pos).param2
)
if gate == "diode" then
set_gate(pos, L.a)
elseif gate == "not" then
set_gate(pos, not L.a)
elseif gate == "nand" then
set_gate(pos, not(L.b and L.d))
elseif gate == "and" then
set_gate(pos, L.b and L.d)
else--if gate == "xor" then
set_gate(pos, (L.b and not L.d) or (not L.b and L.d))
end
end
mesecon:register_on_signal_change(function(pos,node)
if string.find(node.name, "mesecons_gates:")~=nil then
update_gate(pos)
end
end)
minetest.register_craft({
output = 'mesecons_gates:diode_off',
recipe = {

16
mesecons_hydroturbine/init.lua
View File

@ -1,9 +1,12 @@
-- HYDRO_TURBINE
-- Water turbine:
-- Active if flowing >water< above it
-- (does not work with other liquids)
minetest.register_node("mesecons_hydroturbine:hydro_turbine_off", {
drawtype = "nodebox",
tiles = {"jeija_hydro_turbine_off.png"},
groups = {dig_immediate=2, mesecon = 2},
groups = {dig_immediate=2},
description="Water Turbine",
paramtype = "light",
selection_box = {
@ -20,13 +23,16 @@ minetest.register_node("mesecons_hydroturbine:hydro_turbine_off", {
{-0.45, 1.15, -0.1, 0.45, 1.45, 0.1},
{-0.1, 1.15, -0.45, 0.1, 1.45, 0.45}},
},
mesecons = {receptor = {
state = mesecon.state.off
}}
})
minetest.register_node("mesecons_hydroturbine:hydro_turbine_on", {
drawtype = "nodebox",
tiles = {"jeija_hydro_turbine_on.png"},
drop = '"mesecons_hydroturbine:hydro_turbine_off" 1',
groups = {dig_immediate=2,not_in_creative_inventory=1, mesecon = 2},
groups = {dig_immediate=2,not_in_creative_inventory=1},
description="Water Turbine",
paramtype = "light",
selection_box = {
@ -43,6 +49,9 @@ minetest.register_node("mesecons_hydroturbine:hydro_turbine_on", {
{-0.5, 1.15, -0.1, 0.5, 1.45, 0.1},
{-0.1, 1.15, -0.5, 0.1, 1.45, 0.5}},
},
mesecons = {receptor = {
state = mesecon.state.on
}}
})
@ -74,9 +83,6 @@ nodenames = {"mesecons_hydroturbine:hydro_turbine_on"},
end,
})
mesecon:add_receptor_node("mesecons_hydroturbine:hydro_turbine_on")
mesecon:add_receptor_node_off("mesecons_hydroturbine:hydro_turbine_off")
minetest.register_craft({
output = '"mesecons_hydroturbine:hydro_turbine_off" 2',
recipe = {

41
mesecons_insulated/init.lua
View File

@ -1,3 +1,12 @@
function insulated_wire_get_rules(node)
local rules = {{x = 1, y = 0, z = 0},
{x =-1, y = 0, z = 0}}
if node.param2 == 1 or node.param2 == 3 then
return mesecon:rotate_rules_right(rules)
end
return rules
end
minetest.register_node("mesecons_insulated:insulated_on", {
drawtype = "nodebox",
description = "insulated mesecons",
@ -21,9 +30,13 @@ minetest.register_node("mesecons_insulated:insulated_on", {
type = "fixed",
fixed = { -16/32-0.001, -17/32, -3/32, 16/32+0.001, -13/32, 3/32 }
},
groups = {dig_immediate = 3, mesecon = 3, mesecon_conductor_craftable=1, not_in_creative_inventory = 1},
groups = {dig_immediate = 3, not_in_creative_inventory = 1},
drop = "mesecons_insulated:insulated_off",
mesecons = {conductor = {
state = mesecon.state.on,
offstate = "mesecons_insulated:insulated_off",
rules = insulated_wire_get_rules
}}
})
minetest.register_node("mesecons_insulated:insulated_off", {
@ -49,7 +62,12 @@ minetest.register_node("mesecons_insulated:insulated_off", {
type = "fixed",
fixed = { -16/32-0.001, -17/32, -3/32, 16/32+0.001, -13/32, 3/32 }
},
groups = {dig_immediate = 3, mesecon = 3, mesecon_conductor_craftable=1},
groups = {dig_immediate = 3},
mesecons = {conductor = {
state = mesecon.state.off,
onstate = "mesecons_insulated:insulated_on",
rules = insulated_wire_get_rules
}}
})
minetest.register_craft({
@ -61,21 +79,6 @@ minetest.register_craft({
}
})
mesecon:add_rules("insulated_all", { --all possible rules
{x = 1, y = 0, z = 0},
{x =-1, y = 0, z = 0},
{x = 0, y = 0, z = 1},
{x = 0, y = 0, z =-1},})
mesecon:add_rules("insulated", {
{x = 1, y = 0, z = 0},
{x =-1, y = 0, z = 0},})
function insulated_wire_get_rules(param2)
if param2 == 1 or param2 == 3 then
return mesecon:rotate_rules_right(mesecon:get_rules("insulated"))
end
return mesecon:get_rules("insulated")
end
mesecon:register_conductor("mesecons_insulated:insulated_on", "mesecons_insulated:insulated_off", mesecon:get_rules("insulated_all"), insulated_wire_get_rules)
{x =-1, y = 0, z = 0}})

33
mesecons_lamp/init.lua
View File

@ -1,4 +1,7 @@
-- MESELAMPS
-- A lamp is "is an electrical device used to create artificial light" (wikipedia)
-- guess what?
minetest.register_node("mesecons_lamp:lamp_on", {
drawtype = "nodebox",
tiles = {"jeija_meselamp_on.png"},
@ -20,8 +23,13 @@ minetest.register_node("mesecons_lamp:lamp_on", {
wall_bottom = {-0.3125,-0.5,-0.3125,0.3125,-0.375,0.3125},
wall_side = {-0.375,-0.3125,-0.3125,-0.5,0.3125,0.3125},
},
groups = {dig_immediate=3,not_in_creative_inventory=1, mesecon_effector_on = 1, mesecon = 2},
groups = {dig_immediate=3,not_in_creative_inventory=1, mesecon_effector_on = 1},
drop='"mesecons_lamp:lamp_off" 1',
mesecons = {effector = {
action_off = function (pos, node)
mesecon:swap_node(pos, "mesecons_lamp:lamp_off")
end
}}
})
minetest.register_node("mesecons_lamp:lamp_off", {
@ -45,8 +53,13 @@ minetest.register_node("mesecons_lamp:lamp_off", {
wall_bottom = {-0.3125,-0.5,-0.3125,0.3125,-0.375,0.3125},
wall_side = {-0.375,-0.3125,-0.3125,-0.5,0.3125,0.3125},
},
groups = {dig_immediate=3, mesecon_receptor_off = 1, mesecon_effector_off = 1, mesecon = 2},
groups = {dig_immediate=3, mesecon_receptor_off = 1, mesecon_effector_off = 1},
description="Meselamp",
mesecons = {effector = {
action_on = function (pos, node)
mesecon:swap_node(pos, "mesecons_lamp:lamp_on")
end
}}
})
minetest.register_craft({
@ -57,19 +70,3 @@ minetest.register_craft({
{'', '"default:glass"', ''},
}
})
mesecon:register_on_signal_on(function(pos, node)
if node.name == "mesecons_lamp:lamp_off" then
minetest.env:add_node(pos, {name="mesecons_lamp:lamp_on", param2 = node.param2})
nodeupdate(pos)
end
end)
mesecon:register_on_signal_off(function(pos, node)
if node.name == "mesecons_lamp:lamp_on" then
minetest.env:add_node(pos, {name="mesecons_lamp:lamp_off", param2 = node.param2})
nodeupdate(pos)
end
end)
mesecon:register_effector("mesecons_lamp:lamp_on", "mesecons_lamp:lamp_off")

47
mesecons_lightstone/init.lua
View File

@ -1,30 +1,28 @@
function mesecon:lightstone_add(name, base_item, texture_off, texture_on)
minetest.register_node("mesecons_lightstone:lightstone_" .. name .. "_off", {
tiles = {texture_off},
inventory_image = minetest.inventorycube(texture_off),
groups = {cracky=2, mesecon_effector_off = 1, mesecon = 2},
description=name.." Lightstone",
minetest.register_node("mesecons_lightstone:lightstone_" .. name .. "_off", {
tiles = {texture_off},
inventory_image = minetest.inventorycube(texture_off),
groups = {cracky=2, mesecon_effector_off = 1, mesecon = 2},
description=name.." Lightstone",
mesecons = {effector = {
action_on = function (pos, node)
mesecon:swap_node(pos, "mesecons_lightstone:lightstone_" .. name .. "_on")
end
}}
})
minetest.register_node("mesecons_lightstone:lightstone_" .. name .. "_on", {
tiles = {texture_on},
inventory_image = minetest.inventorycube(texture_on),
groups = {cracky=2,not_in_creative_inventory=1, mesecon = 2},
drop = "node mesecons_lightstone:lightstone_" .. name .. "_off 1",
light_source = LIGHT_MAX-2,
description=name.." Lightstone",
minetest.register_node("mesecons_lightstone:lightstone_" .. name .. "_on", {
tiles = {texture_on},
inventory_image = minetest.inventorycube(texture_on),
groups = {cracky=2,not_in_creative_inventory=1, mesecon = 2},
drop = "node mesecons_lightstone:lightstone_" .. name .. "_off 1",
light_source = LIGHT_MAX-2,
mesecons = {effector = {
action_off = function (pos, node)
mesecon:swap_node(pos, "mesecons_lightstone:lightstone_" .. name .. "_off")
end
}}
})
assert(loadstring('mesecon:register_on_signal_on(function(pos, node) \n \
if node.name == "mesecons_lightstone:lightstone_' .. name .. '_off" then \n \
minetest.env:add_node(pos, {name="mesecons_lightstone:lightstone_' .. name .. '_on"}) \n \
nodeupdate(pos) \n \
end \n \
end)'))()
assert(loadstring('mesecon:register_on_signal_off(function(pos, node) \n \
if node.name == "mesecons_lightstone:lightstone_' .. name .. '_on" then \n \
minetest.env:add_node(pos, {name="mesecons_lightstone:lightstone_' .. name .. '_off"}) \n \
nodeupdate(pos) \n \
end \n \
end)'))()
minetest.register_craft({
output = "node mesecons_lightstone:lightstone_" .. name .. "_off 1",
recipe = {
@ -33,7 +31,6 @@ function mesecon:lightstone_add(name, base_item, texture_off, texture_on)
{'','group:mesecon_conductor_craftable',''},
}
})
mesecon:register_effector("mesecons_lightstone:lightstone_" .. name .. "_on", "mesecons_lightstone:lightstone_" .. name .. "_off")
end

63
mesecons_microcontroller/init.lua
View File

@ -23,6 +23,33 @@ if tostring(d)..tostring(c)..tostring(b)..tostring(a) ~= "0000" then
else
groups = {dig_immediate=2, mesecon = 3}
end
local rules={}
if (a == 1) then table.insert(rules, {x = -1, y = 0, z = 0}) end
if (b == 1) then table.insert(rules, {x = 0, y = 0, z = 1}) end
if (c == 1) then table.insert(rules, {x = 1, y = 0, z = 0}) end
if (d == 1) then table.insert(rules, {x = 0, y = 0, z = -1}) end
local input_rules={}
if (a == 0) then table.insert(input_rules, {x = -1, y = 0, z = 0}) end
if (b == 0) then table.insert(input_rules, {x = 0, y = 0, z = 1}) end
if (c == 0) then table.insert(input_rules, {x = 1, y = 0, z = 0}) end
if (d == 0) then table.insert(input_rules, {x = 0, y = 0, z = -1}) end
mesecon:add_rules(nodename, rules)
local mesecons = {effector =
{
rules = input_rules,
action_change = function (pos, node)
update_yc(pos)
end
}}
if nodename ~= "mesecons_microcontroller:microcontroller0000" then
mesecons.receptor = {
state = mesecon.state.on,
rules = rules
}
end
minetest.register_node(nodename, {
description = "Microcontroller",
drawtype = "nodebox",
@ -101,25 +128,12 @@ minetest.register_node(nodename, {
yc_reset (pos)
update_yc(pos)
end,
mesecons = mesecons,
after_dig_node = function (pos, node)
rules = mesecon:get_rules(node.name)
mesecon:receptor_off(pos, rules)
end,
})
local rules={}
if (a == 1) then table.insert(rules, {x = -1, y = 0, z = 0}) end
if (b == 1) then table.insert(rules, {x = 0, y = 0, z = 1}) end
if (c == 1) then table.insert(rules, {x = 1, y = 0, z = 0}) end
if (d == 1) then table.insert(rules, {x = 0, y = 0, z = -1}) end
local input_rules={}
if (a == 0) then table.insert(input_rules, {x = -1, y = 0, z = 0}) end
if (b == 0) then table.insert(input_rules, {x = 0, y = 0, z = 1}) end
if (c == 0) then table.insert(input_rules, {x = 1, y = 0, z = 0}) end
if (d == 0) then table.insert(input_rules, {x = 0, y = 0, z = -1}) end
mesecon:add_rules(nodename, rules)
mesecon:register_effector(nodename, nodename, input_rules)
if nodename ~= "mesecons_microcontroller:microcontroller0000" then
mesecon:add_receptor_node(nodename, rules)
end
end
end
end
@ -682,16 +696,3 @@ function yc_overheat_off(pos)
rules = mesecon:get_rules("mesecons_microcontroller:microcontroller1111")
mesecon:receptor_off(pos, rules)
end
mesecon:register_on_signal_change(function(pos, node)
if string.find(node.name, "mesecons_microcontroller:microcontroller")~=nil then
update_yc(pos)
end
end)
minetest.register_on_dignode(function(pos, node)
if string.find(node.name, "mesecons_microcontroller:microcontroller") then
rules = mesecon:get_rules(node.name)
mesecon:receptor_off(pos, rules)
end
end)

163
mesecons_movestones/init.lua
View File

@ -1,33 +1,53 @@
-- MOVESTONE
-- Non-sticky:
-- Moves along mesecon lines
-- Pushes all blocks in front of it
--
-- Sticky one
-- Moves along mesecon lines
-- Pushes all block in front of it
-- Pull all blocks in its back
function mesecon:get_movestone_direction(pos)
getactivated=0
getactivated = 0
local lpos
local getactivated=0
local rules=mesecon:get_rules("movestone")
local getactivated = 0
local rules = {
{x=0, y=1, z=-1},
{x=0, y=0, z=-1},
{x=0, y=-1, z=-1},
{x=0, y=1, z=1},
{x=0, y=-1, z=1},
{x=0, y=0, z=1},
{x=1, y=0, z=0},
{x=1, y=1, z=0},
{x=1, y=-1, z=0},
{x=-1, y=1, z=0},
{x=-1, y=-1, z=0},
{x=-1, y=0, z=0}}
lpos={x=pos.x+1, y=pos.y, z=pos.z}
for n=1, 3 do
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
return {x=0, y=0, z=-1}
end
end
lpos={x=pos.x-1, y=pos.y, z=pos.z}
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
return {x=0, y=0, z=1}
end
end
lpos={x=pos.x, y=pos.y, z=pos.z+1}
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
return {x=-1, y=0, z=0}
end
end
lpos={x=pos.x, y=pos.y, z=pos.z-1}
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
return {x=1, y=0, z=0}
@ -41,8 +61,27 @@ minetest.register_node("mesecons_movestones:movestone", {
legacy_facedir_simple = true,
groups = {cracky=3},
description="Movestone",
mesecons = {effector = {
action_on = function (pos, node)
local direction=mesecon:get_movestone_direction(pos)
if not direction then return end
local checknode={}
local collpos={x=pos.x, y=pos.y, z=pos.z}
repeat -- Check if it collides with a stopper
collpos = addPosRule(collpos, direction)
checknode=minetest.env:get_node(collpos)
if mesecon:is_mvps_stopper(checknode.name) then
return
end
until checknode.name=="air"
or checknode.name=="ignore"
or not(minetest.registered_nodes[checknode.name].liquidtype == "none")
minetest.env:remove_node(pos)
mesecon:update_autoconnect(pos)
minetest.env:add_entity(pos, "mesecons_movestones:movestone_entity")
end
}}
})
mesecon:register_effector("mesecons_movestones:movestone", "mesecons_movestones:movestone")
minetest.register_entity("mesecons_movestones:movestone_entity", {
physical = false,
@ -50,10 +89,6 @@ minetest.register_entity("mesecons_movestones:movestone_entity", {
textures = {"jeija_movestone_side.png", "jeija_movestone_side.png", "jeija_movestone_side.png", "jeija_movestone_side.png", "jeija_movestone_arrows.png", "jeija_movestone_arrows.png"},
collisionbox = {-0.5,-0.5,-0.5, 0.5,0.5,0.5},
visual = "cube",
--on_activate = function(self, staticdata)
--self.object:setsprite({x=0,y=0}, 1, 0, true)
--self.object:setvelocity({x=-3, y=0, z=0})
--end,
on_punch = function(self, hitter)
self.object:remove()
@ -73,7 +108,7 @@ minetest.register_entity("mesecons_movestones:movestone_entity", {
self.object:setvelocity({x=direction.x*3, y=direction.y*3, z=direction.z*3})
mesecon:mvps_push(pos, direction)
end
end,
})
minetest.register_craft({
@ -85,28 +120,6 @@ minetest.register_craft({
}
})
mesecon:register_on_signal_on(function (pos, node)
if node.name=="mesecons_movestones:movestone" then
local direction=mesecon:get_movestone_direction(pos)
if not direction then return end
local checknode={}
local collpos={x=pos.x, y=pos.y, z=pos.z}
repeat -- Check if it collides with a stopper
collpos={x=collpos.x+direction.x, y=collpos.y+direction.y, z=collpos.z+direction.z}
checknode=minetest.env:get_node(collpos)
if mesecon:is_mvps_stopper(checknode.name) then
return
end
until checknode.name=="air"
or checknode.name=="ignore"
or not(minetest.registered_nodes[checknode.name].liquidtype == "none")
minetest.env:remove_node(pos)
nodeupdate(pos)
minetest.env:add_entity(pos, "mesecons_movestones:movestone_entity")
end
end)
-- STICKY_MOVESTONE
@ -118,8 +131,36 @@ minetest.register_node("mesecons_movestones:sticky_movestone", {
legacy_facedir_simple = true,
groups = {cracky=3},
description="Sticky Movestone",
mesecons = {effector = {
action_on = function (pos, node)
local direction=mesecon:get_movestone_direction(pos)
if not direction then return end
local checknode={}
local collpos={x=pos.x, y=pos.y, z=pos.z}
repeat -- Check if it collides with a stopper
collpos = addPosRule(collpos, direction)
checknode=minetest.env:get_node(collpos)
if mesecon:is_mvps_stopper(checknode.name) then
return
end
until checknode.name=="air"
or checknode.name=="ignore"
or not(minetest.registered_nodes[checknode.name].liquidtype == "none")
repeat -- Check if it collides with a stopper (pull direction)
collpos={x=collpos.x-direction.x, y=collpos.y-direction.y, z=collpos.z-direction.z}
checknode=minetest.env:get_node(collpos)
if mesecon:is_mvps_stopper(checknode.name) then
return
end
until checknode.name=="air"
or checknode.name=="ignore"
or not(minetest.registered_nodes[checknode.name].liquidtype == "none")
minetest.env:remove_node(pos)
mesecon:update_autoconnect(pos)
minetest.env:add_entity(pos, "mesecons_movestones:sticky_movestone_entity")
end
}}
})
mesecon:register_effector("mesecons_movestones:sticky_movestone", "mesecons_movestones:sticky_movestone")
minetest.register_craft({
output = '"mesecons_movestones:sticky_movestone" 2',
@ -146,8 +187,6 @@ minetest.register_entity("mesecons_movestones:sticky_movestone_entity", {
local direction=mesecon:get_movestone_direction(colp)
if not direction then
--or (minetest.env:get_node_or_nil(pos).name ~="air"
--and minetest.env:get_node_or_nil(pos).name ~= nil) then
minetest.env:add_node(pos, {name="mesecons_movestones:sticky_movestone"})
self.object:remove()
return
@ -159,49 +198,5 @@ minetest.register_entity("mesecons_movestones:sticky_movestone_entity", {
--STICKY
mesecon:mvps_pull_all(pos, direction)
end
end,
})
mesecon:register_on_signal_on(function (pos, node)
if node.name=="mesecons_movestones:sticky_movestone" then
local direction=mesecon:get_movestone_direction(pos)
if not direction then return end
local checknode={}
local collpos={x=pos.x, y=pos.y, z=pos.z}
repeat -- Check if it collides with a stopper
collpos={x=collpos.x+direction.x, y=collpos.y+direction.y, z=collpos.z+direction.z}
checknode=minetest.env:get_node(collpos)
if mesecon:is_mvps_stopper(checknode.name) then
return
end
until checknode.name=="air"
or checknode.name=="ignore"
or not(minetest.registered_nodes[checknode.name].liquidtype == "none")
repeat -- Check if it collides with a stopper (pull direction)
collpos={x=collpos.x-direction.x, y=collpos.y-direction.y, z=collpos.z-direction.z}
checknode=minetest.env:get_node(collpos)
if mesecon:is_mvps_stopper(checknode.name) then
return
end
until checknode.name=="air"
or checknode.name=="ignore"
or not(minetest.registered_nodes[checknode.name].liquidtype == "none")
minetest.env:remove_node(pos)
nodeupdate(pos)
minetest.env:add_entity(pos, "mesecons_movestones:sticky_movestone_entity")
end
end)
mesecon:add_rules("movestone", {
{x=0, y=1, z=-1},
{x=0, y=0, z=-1},
{x=0, y=-1, z=-1},
{x=0, y=1, z=1},
{x=0, y=-1, z=1},
{x=0, y=0, z=1},
{x=1, y=0, z=0},
{x=1, y=1, z=0},
{x=1, y=-1, z=0},
{x=-1, y=1, z=0},
{x=-1, y=-1, z=0},
{x=-1, y=0, z=0}})

31
mesecons_noteblock/init.lua
View File

@ -1,15 +1,25 @@
minetest.register_node("mesecons_noteblock:noteblock", {
description = "Noteblock",
tiles = {"mesecons_noteblock.png"},
groups = {snappy=2,choppy=2,oddly_breakable_by_hand=2, mesecon = 2},
groups = {snappy=2,choppy=2,oddly_breakable_by_hand=2},
drawtype = "allfaces_optional",
visual_scale = 1.3,
paramtype="light",
after_place_node = function(pos)
minetest.env:add_node(pos, {name="mesecons_noteblock:noteblock", param2=0})
end
end,
on_punch = function (pos, node) -- change sound when punched
local param2 = node.param2+1
if param2==12 then param2=0 end
minetest.env:add_node(pos, {name = node.name, param2 = param2})
mesecon.noteblock_play(pos, param2)
end,
mesecons = {effector = { -- play sound when activated
action_on = function (pos, node)
mesecon.noteblock_play(pos, node.param2)
end
}}
})
mesecon:register_effector("mesecons_noteblock:noteblock", "mesecons_noteblock:noteblock")
minetest.register_craft({
output = '"mesecons_noteblock:noteblock" 1',
@ -20,15 +30,6 @@ minetest.register_craft({
}
})
minetest.register_on_punchnode(function (pos, node)
if node.name=="mesecons_noteblock:noteblock" then
local param2 = node.param2+1
if param2==12 then param2=0 end
minetest.env:add_node(pos, {name=node.name, param2=param2})
mesecon.noteblock_play(pos, param2)
end
end)
mesecon.noteblock_play = function (pos, param2)
local soundname
if param2==8 then
@ -75,9 +76,3 @@ mesecon.noteblock_play = function (pos, param2)
minetest.sound_play(soundname,
{pos = pos, gain = 1.0, max_hear_distance = 32,})
end
mesecon:register_on_signal_on(function(pos, node)
if node.name=="mesecons_noteblock:noteblock" then
mesecon.noteblock_play(pos, node.param2)
end
end)

26
mesecons_pistons/init.lua
View File

@ -1,5 +1,11 @@
--PISTONS
local update = function(pos, node)
local timer = minetest.env:get_node_timer(pos)
timer:stop()
timer:start(0)
end
minetest.register_node("mesecons_pistons:piston_normal", {
description = "Piston",
tiles = {"jeija_piston_tb.png", "jeija_piston_tb.png", "jeija_piston_tb.png", "jeija_piston_tb.png", "jeija_piston_tb.png", "jeija_piston_side.png"},
@ -25,8 +31,10 @@ minetest.register_node("mesecons_pistons:piston_normal", {
end
return false
end,
mesecons = {effector={
action_change = update
}}
})
mesecon:register_effector("mesecons_pistons:piston_normal", "mesecons_pistons:piston_normal")
minetest.register_node("mesecons_pistons:piston_sticky", {
description = "Sticky Piston",
@ -53,8 +61,10 @@ minetest.register_node("mesecons_pistons:piston_sticky", {
end
return false
end,
mesecons = {effector={
action_change = update
}}
})
mesecon:register_effector("mesecons_pistons:piston_sticky", "mesecons_pistons:piston_sticky")
minetest.register_craft({
output = '"mesecons_pistons:piston_normal" 2',
@ -127,18 +137,6 @@ minetest.register_node("mesecons_pistons:piston_pusher_sticky", {
mesecon:register_mvps_stopper("mesecons_pistons:piston_pusher_normal")
mesecon:register_mvps_stopper("mesecons_pistons:piston_pusher_sticky")
local update = function(pos, node)
if node.name ~= "mesecons_pistons:piston_normal" and node.name ~= "mesecons_pistons:piston_sticky" then
return
end
local timer = minetest.env:get_node_timer(pos)
timer:stop()
timer:start(0)
end
mesecon:register_on_signal_on(update) --push action
mesecon:register_on_signal_off(update) --pull action
function mesecon:piston_push(pos)
local node = minetest.env:get_node(pos)
local dir = mesecon:piston_get_direction(node)

8
mesecons_powerplant/init.lua
View File

@ -1,4 +1,5 @@
-- The POWER_PLANT
-- The POWER_PLANT
-- Just emits power. always.
minetest.register_node("mesecons_powerplant:power_plant", {
drawtype = "plantlike",
@ -14,6 +15,9 @@ minetest.register_node("mesecons_powerplant:power_plant", {
type = "fixed",
fixed = {-0.1, -0.5, -0.1, 0.1, -0.5+0.6, 0.1},
},
mesecons = {receptor = {
state = mesecon.state.on
}}
})
minetest.register_craft({
@ -24,5 +28,3 @@ minetest.register_craft({
{'"default:sapling"'},
}
})
mesecon:add_receptor_node("mesecons_powerplant:power_plant")

43
mesecons_pressureplates/init.lua
View File

@ -25,7 +25,7 @@ minetest.register_node("mesecons_pressureplates:pressure_plate_wood_off", {
local objpos=obj:getpos()
if objpos.y>pos.y-1 and objpos.y<pos.y then
minetest.env:add_node(pos, {name="mesecons_pressureplates:pressure_plate_wood_on"})
mesecon:receptor_on(pos, mesecon:get_rules("pressureplate"))
mesecon:receptor_on(pos)
end
end
return true
@ -57,7 +57,7 @@ minetest.register_node("mesecons_pressureplates:pressure_plate_wood_on", {
local objs = minetest.env:get_objects_inside_radius(pos, 1)
if objs[1]==nil then
minetest.env:add_node(pos, {name="mesecons_pressureplates:pressure_plate_wood_off"})
mesecon:receptor_off(pos, mesecon:get_rules("pressureplate"))
mesecon:receptor_off(pos)
end
return true
end,
@ -92,7 +92,7 @@ minetest.register_node("mesecons_pressureplates:pressure_plate_stone_off", {
type = "fixed",
fixed = { -7/16, -8/16, -7/16, 7/16, -7/16, 7/16 },
},
groups = {snappy=2,choppy=2,oddly_breakable_by_hand=3, mesecon = 2},
groups = {snappy=2,choppy=2,oddly_breakable_by_hand=3},
description="Stone Pressure Plate",
on_timer = function(pos, elapsed)
@ -101,7 +101,7 @@ minetest.register_node("mesecons_pressureplates:pressure_plate_stone_off", {
local objpos=obj:getpos()
if objpos.y>pos.y-1 and objpos.y<pos.y then
minetest.env:add_node(pos, {name="mesecons_pressureplates:pressure_plate_stone_on"})
mesecon:receptor_on(pos, mesecon:get_rules("pressureplate"))
mesecon:receptor_on(pos)
end
end
return true
@ -110,6 +110,10 @@ minetest.register_node("mesecons_pressureplates:pressure_plate_stone_off", {
on_construct = function(pos)
minetest.env:get_node_timer(pos):start(PRESSURE_PLATE_INTERVAL)
end,
mesecons = {receptor = {
state = mesecon.state.off
}}
})
minetest.register_node("mesecons_pressureplates:pressure_plate_stone_on", {
@ -126,14 +130,14 @@ minetest.register_node("mesecons_pressureplates:pressure_plate_stone_on", {
type = "fixed",
fixed = { -7/16, -8/16, -7/16, 7/16, -31/64, 7/16 },
},
groups = {snappy=2,choppy=2,oddly_breakable_by_hand=3,not_in_creative_inventory=1, mesecon = 2},
groups = {snappy=2,choppy=2,oddly_breakable_by_hand=3,not_in_creative_inventory=1},
drop='"mesecons_pressureplates:pressure_plate_stone_off" 1',
on_timer = function(pos, elapsed)
local objs = minetest.env:get_objects_inside_radius(pos, 1)
if objs[1]==nil then
minetest.env:add_node(pos, {name="mesecons_pressureplates:pressure_plate_stone_off"})
mesecon:receptor_off(pos, mesecon:get_rules("pressureplate"))
mesecon:receptor_off(pos)
end
return true
end,
@ -141,6 +145,10 @@ minetest.register_node("mesecons_pressureplates:pressure_plate_stone_on", {
on_construct = function(pos)
minetest.env:get_node_timer(pos):start(PRESSURE_PLATE_INTERVAL)
end,
mesecons = {receptor = {
state = mesecon.state.off
}}
})
minetest.register_craft({
@ -149,26 +157,3 @@ minetest.register_craft({
{'"default:cobble"', '"default:cobble"'},
}
})
mesecon:add_rules("pressureplate",
{{x=0, y=1, z=-1},
{x=0, y=0, z=-1},
{x=0, y=-1, z=-1},
{x=0, y=1, z=1},
{x=0, y=-1, z=1},
{x=0, y=0, z=1},
{x=1, y=0, z=0},
{x=1, y=1, z=0},
{x=1, y=-1, z=0},
{x=-1, y=1, z=0},
{x=-1, y=-1, z=0},
{x=-1, y=0, z=0},
{x=0, y=-1, z=0},
{x=0, y=-2, z=0},
{x=0, y=1, z=0}})
mesecon:add_receptor_node("mesecons_pressureplates:pressure_plate_wood_on", mesecon:get_rules("pressureplate"))
mesecon:add_receptor_node_off("mesecons_pressureplates:pressure_plate_wood_off", mesecon:get_rules("pressureplate"))
mesecon:add_receptor_node("mesecons_pressureplates:pressure_plate_stone_on", mesecon:get_rules("pressureplate"))
mesecon:add_receptor_node_off("mesecons_pressureplates:pressure_plate_stone_off", mesecon:get_rules("pressureplate"))

44
mesecons_random/init.lua
View File

@ -3,12 +3,16 @@
minetest.register_node("mesecons_random:removestone", {
tiles = {"jeija_removestone.png"},
inventory_image = minetest.inventorycube("jeija_removestone_inv.png"),
groups = {cracky=3, mesecon=2},
groups = {cracky=3},
description="Removestone",
mesecons = {effector = {
action_on = function (pos, node)
minetest.env:remove_node(pos)
mesecon:update_autoconnect(pos)
end
}}
})
mesecon:register_effector(nil, "mesecons_random:removestone")
minetest.register_craft({
output = 'mesecons_random:removestone 4',
recipe = {
@ -18,12 +22,6 @@ minetest.register_craft({
}
})
mesecon:register_on_signal_on(function(pos, node)
if node.name == "mesecons_random:removestone" then
minetest.env:remove_node(pos)
end
end)
-- GHOSTSTONE
minetest.register_node("mesecons_random:ghoststone", {
@ -31,8 +29,13 @@ minetest.register_node("mesecons_random:ghoststone", {
tiles = {"jeija_ghoststone.png"},
is_ground_content = true,
inventory_image = minetest.inventorycube("jeija_ghoststone_inv.png"),
groups = {cracky=3, mesecon=2},
groups = {cracky=3},
sounds = default.node_sound_stone_defaults(),
mesecons = {effector = {
action_on = function (pos, node)
minetest.env:add_node(pos, {name="mesecons_random:ghoststone_active"})
end
}}
})
minetest.register_node("mesecons_random:ghoststone_active", {
@ -41,10 +44,13 @@ minetest.register_node("mesecons_random:ghoststone_active", {
walkable = false,
diggable = false,
sunlight_propagates = true,
groups = {mesecon=2},
mesecons = {effector = {
action_off = function (pos, node)
minetest.env:add_node(pos, {name="mesecons_random:ghoststone"})
end
}}
})
mesecon:register_effector("mesecons_random:ghoststone_active", "mesecons_random:ghoststone")
minetest.register_craft({
output = 'mesecons_random:ghoststone 4',
@ -54,17 +60,3 @@ minetest.register_craft({
{"default:steel_ingot", "default:cobble", "default:steel_ingot"},
}
})
mesecon:register_on_signal_on(function(pos, node)
if node.name == "mesecons_random:ghoststone" then
minetest.env:add_node(pos, {name="mesecons_random:ghoststone_active"})
nodeupdate(pos)
end
end)
mesecon:register_on_signal_off(function(pos, node)
if node.name == "mesecons_random:ghoststone_active" then
minetest.env:add_node(pos, {name="mesecons_random:ghoststone"})
nodeupdate(pos)
end
end)

66
mesecons_receiver/init.lua
View File

@ -1,10 +1,23 @@
rcvboxes = {
{ -3/16, -3/16 , -8/16 , 3/16, 3/16, -13/32 }, -- the smaller bump
{ -5/32, -5/32 , -13/32 , 5/32, 5/32, -12/32 }, -- the receiver itself
{ -3/32, -.5-1/32, -.5 , 3/32, 0 , -.5002+3/32 }, -- the vertical wire bit
{ -3/32, -17/32 , -7/16+0.002 , 3/32, -13/32, 16/32+0.001 } -- the horizontal wire
{ -1/32, -1/32 , -3/2 , 1/32, 1/32, -1/2 }, -- the wire through the block
{ -2/32, -.5-1/32, -.5 , 2/32, 0 , -.5002+3/32 }, -- the vertical wire bit
{ -2/32, -17/32 , -7/16+0.002 , 2/32, -14/32, 16/32+0.001 } -- the horizontal wire
}
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)
elseif node.param2 == 3 then
rules = mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
elseif node.param2 == 0 then
rules = mesecon:rotate_rules_right(rules)
end
return rules
end
minetest.register_node("mesecons_receiver:receiver_on", {
drawtype = "nodebox",
tiles = {
@ -18,6 +31,7 @@ minetest.register_node("mesecons_receiver:receiver_on", {
paramtype = "light",
paramtype2 = "facedir",
sunlight_propagates = true,
walkable = false,
selection_box = {
type = "fixed",
fixed = { -3/16, -8/16, -8/16, 3/16, 3/16, 8/16 }
@ -26,9 +40,13 @@ minetest.register_node("mesecons_receiver:receiver_on", {
type = "fixed",
fixed = rcvboxes
},
groups = {dig_immediate = 3, mesecon = 3, not_in_creative_inventory = 1},
groups = {dig_immediate = 3, not_in_creative_inventory = 1},
drop = "mesecons:wire_00000000_off",
mesecons = {conductor = {
state = mesecon.state.on,
rules = receiver_get_rules,
offstate = "mesecons_receiver:receiver_off"
}}
})
minetest.register_node("mesecons_receiver:receiver_off", {
@ -45,6 +63,7 @@ minetest.register_node("mesecons_receiver:receiver_off", {
paramtype = "light",
paramtype2 = "facedir",
sunlight_propagates = true,
walkable = false,
selection_box = {
type = "fixed",
fixed = { -3/16, -8/16, -8/16, 3/16, 3/16, 8/16 }
@ -53,8 +72,13 @@ minetest.register_node("mesecons_receiver:receiver_off", {
type = "fixed",
fixed = rcvboxes
},
groups = {dig_immediate = 3, mesecon = 3, not_in_creative_inventory = 1},
groups = {dig_immediate = 3, not_in_creative_inventory = 1},
drop = "mesecons:wire_00000000_off",
mesecons = {conductor = {
state = mesecon.state.off,
rules = receiver_get_rules,
onstate = "mesecons_receiver:receiver_on"
}}
})
mesecon:add_rules("receiver_pos", {{x = 2, y = 0, z = 0}})
@ -65,34 +89,6 @@ mesecon:add_rules("receiver_pos_all", {
{x = 0, y = 0, z = 2},
{x = 0, y = 0, z =-2}})
mesecon:add_rules("mesecon_receiver", {
{x = 1, y = 0, z = 0},
{x = -2, y = 0, z = 0},})
mesecon:add_rules("mesecon_receiver_all", {
{x = 1, y = 0, z = 0},
{x =-2, y = 0, z = 0},
{x =-1, y = 0, z = 0},
{x = 2, y = 0, z = 0},
{x = 0, y = 0, z = 1},
{x = 0, y = 0, z =-2},
{x = 1, y = 0, z =-1},
{x =-2, y = 0, z = 2},})
function receiver_get_rules(param2)
local rules = mesecon:get_rules("mesecon_receiver")
if param2 == 2 then
rules = mesecon:rotate_rules_left(rules)
elseif param2 == 3 then
rules = mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
elseif param2 == 0 then
rules = mesecon:rotate_rules_right(rules)
end
return rules
end
mesecon:register_conductor("mesecons_receiver:receiver_on", "mesecons_receiver:receiver_off", mesecon:get_rules("mesecon_receiver_all"), receiver_get_rules)
function mesecon:receiver_get_pos_from_rcpt(pos, param2)
local rules = mesecon:get_rules("receiver_pos")
if param2 == nil then param2 = minetest.env:get_node(pos).param2 end
@ -119,7 +115,7 @@ function mesecon:receiver_place(rcpt_pos)
minetest.env:dig_node(pos)
if mesecon:is_power_on(rcpt_pos) then
minetest.env:add_node(pos, {name = "mesecons_receiver:receiver_on", param2 = node.param2})
mesecon:receptor_on(pos, receiver_get_rules(node.param2))
mesecon:receptor_on(pos, receiver_get_rules(node))
else
minetest.env:add_node(pos, {name = "mesecons_receiver:receiver_off", param2 = node.param2})
end

14
mesecons_solarpanel/init.lua
View File

@ -21,8 +21,10 @@ minetest.register_node("mesecons_solarpanel:solar_panel_on", {
wall_side = { -8/16, -7/16, -7/16, -7/16, 7/16, 7/16 },
},
drop = "mesecons_solarpanel:solar_panel_off",
groups = {dig_immediate=3, mesecon = 2, not_in_creative_inventory = 1},
description="Solar Panel",
groups = {dig_immediate=3, not_in_creative_inventory = 1},
mesecons = {receptor = {
state = mesecon.state.on
}}
})
-- Solar Panel
@ -47,8 +49,11 @@ minetest.register_node("mesecons_solarpanel:solar_panel_off", {
wall_top = { -7/16, 7/16, -7/16, 7/16, 8/16, 7/16 },
wall_side = { -8/16, -7/16, -7/16, -7/16, 7/16, 7/16 },
},
groups = {dig_immediate=3, mesecon = 2},
groups = {dig_immediate=3},
description="Solar Panel",
mesecons = {receptor = {
state = mesecon.state.off
}}
})
minetest.register_craft({
@ -86,6 +91,3 @@ minetest.register_abm(
end
end,
})
mesecon:add_receptor_node("mesecons_solarpanel:solar_panel_on")
mesecon:add_receptor_node_off("mesecons_solarpanel:solar_panel_off")

34
mesecons_switch/init.lua
View File

@ -3,32 +3,30 @@
minetest.register_node("mesecons_switch:mesecon_switch_off", {
tiles = {"jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_off.png"},
paramtype2="facedir",
groups = {dig_immediate=2, mesecon = 2},
description="Switch",
groups = {dig_immediate=2},
description="Switch",
mesecons = {receptor = {
state = mesecon.state.off
}},
on_punch = function(pos, node)
mesecon:swap_node(pos, "mesecons_switch:mesecon_switch_on")
mesecon:receptor_on(pos)
end
})
minetest.register_node("mesecons_switch:mesecon_switch_on", {
tiles = {"jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_side.png", "jeija_mesecon_switch_on.png"},
paramtype2="facedir",
groups = {dig_immediate=2,not_in_creative_inventory=1, mesecon = 2},
groups = {dig_immediate=2,not_in_creative_inventory=1},
drop='"mesecons_switch:mesecon_switch_off" 1',
description="Switch",
})
mesecon:register_receptor("mesecons_switch:mesecon_switch_on", "mesecons_switch:mesecon_switch_off")
minetest.register_on_punchnode(function(pos, node, puncher)
if node.name == "mesecons_switch:mesecon_switch_on" then
minetest.env:add_node(pos, {name="mesecons_switch:mesecon_switch_off", param2=node.param2})
nodeupdate(pos)
mesecons = {receptor = {
state = mesecon.state.on
}},
on_punch = function(pos, node)
mesecon:swap_node(pos, "mesecons_switch:mesecon_switch_off")
mesecon:receptor_off(pos)
end
if node.name == "mesecons_switch:mesecon_switch_off" then
minetest.env:add_node(pos, {name="mesecons_switch:mesecon_switch_on", param2=node.param2})
nodeupdate(pos)
mesecon:receptor_on(pos)
end
end)
})
minetest.register_craft({
output = '"mesecons_switch:mesecon_switch_off" 2',

BIN
mesecons_textures/textures/jeija_ic.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 462 B

BIN
mesecons_textures/textures/jeija_wireless_inverter_off.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 635 B

BIN
mesecons_textures/textures/jeija_wireless_inverter_on.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 715 B

BIN
mesecons_textures/textures/jeija_wireless_inverter_tb.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 678 B

BIN
mesecons_textures/textures/jeija_wireless_receiver_off.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 579 B

BIN
mesecons_textures/textures/jeija_wireless_receiver_on.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 620 B

BIN
mesecons_textures/textures/jeija_wireless_receiver_tb_off.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 678 B

BIN
mesecons_textures/textures/jeija_wireless_receiver_tb_on.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 678 B

BIN
mesecons_textures/textures/jeija_wireless_transmitter_off.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 590 B

BIN
mesecons_textures/textures/jeija_wireless_transmitter_on.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 621 B

BIN
mesecons_textures/textures/jeija_wireless_transmitter_tb.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 678 B

BIN
mesecons_textures/textures/receiver_bottom_off.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 242 B

After

Width:  |  Height:  |  Size: 494 B

BIN
mesecons_textures/textures/receiver_bottom_on.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 247 B

After

Width:  |  Height:  |  Size: 239 B

BIN
mesecons_textures/textures/receiver_fb_off.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 374 B

After

Width:  |  Height:  |  Size: 494 B

BIN
mesecons_textures/textures/receiver_fb_on.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 517 B

After

Width:  |  Height:  |  Size: 239 B

BIN
mesecons_textures/textures/receiver_lr_off.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 317 B

After

Width:  |  Height:  |  Size: 494 B

BIN
mesecons_textures/textures/receiver_lr_on.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 321 B

After

Width:  |  Height:  |  Size: 239 B

BIN
mesecons_textures/textures/receiver_top_off.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 240 B

After

Width:  |  Height:  |  Size: 494 B

BIN
mesecons_textures/textures/receiver_top_on.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 245 B

After

Width:  |  Height:  |  Size: 239 B

146
mesecons_torch/init.lua
View File

@ -1,30 +1,74 @@
--MESECON TORCHES
local torch_get_rules = function(node)
local rules = {
{x=1, y=0, z=0},
{x=0, y=0, z=1},
{x=0, y=0, z=-1},
{x=0, y=1, z=0},
{x=0, y=-1, z=0}}
if node.param2 == 5 then
rules=mesecon:rotate_rules_right(rules)
elseif node.param2 == 2 then
rules=mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules)) --180 degrees
elseif node.param2 == 4 then
rules=mesecon:rotate_rules_left(rules)
elseif node.param2 == 1 then
rules=mesecon:rotate_rules_down(rules)
elseif node.param2 == 0 then
rules=mesecon:rotate_rules_up(rules)
end
return rules
end
local torch_get_input_rules = function(node)
local rules = {x=0, y=0, z=0}
if node.param2 == 4 then
rules.z = -2
elseif node.param2 == 2 then
rules.x = -2
elseif node.param2 == 5 then
rules.z = 2
elseif node.param2 == 3 then
rules.x = 2
elseif node.param2 == 1 then
rules.y = 2
elseif node.param2 == 0 then
rules.y = -2
end
return rules
end
minetest.register_craft({
output = '"mesecons_torch:mesecon_torch_on" 4',
recipe = {
{"group:mesecon_conductor_craftable"},
{"default:stick"},
}
output = '"mesecons_torch:mesecon_torch_on" 4',
recipe = {
{"group:mesecon_conductor_craftable"},
{"default:stick"},
}
})
minetest.register_node("mesecons_torch:mesecon_torch_off", {
drawtype = "torchlike",
tiles = {"jeija_torches_off.png", "jeija_torches_off_ceiling.png", "jeija_torches_off_side.png"},
inventory_image = "jeija_torches_off.png",
paramtype = "light",
walkable = false,
paramtype2 = "wallmounted",
selection_box = {
type = "wallmounted",
wall_top = {-0.1, 0.5-0.6, -0.1, 0.1, 0.5, 0.1},
wall_bottom = {-0.1, -0.5, -0.1, 0.1, -0.5+0.6, 0.1},
wall_side = {-0.5, -0.1, -0.1, -0.5+0.6, 0.1, 0.1},
},
legacy_wallmounted = true,
groups = {dig_immediate=3,not_in_creative_inventory=1, mesecon = 2},
drop = '"mesecons_torch:mesecon_torch_on" 1',
description="Mesecon Torch",
drawtype = "torchlike",
tiles = {"jeija_torches_off.png", "jeija_torches_off_ceiling.png", "jeija_torches_off_side.png"},
inventory_image = "jeija_torches_off.png",
paramtype = "light",
walkable = false,
paramtype2 = "wallmounted",
selection_box = {
type = "wallmounted",
wall_top = {-0.1, 0.5-0.6, -0.1, 0.1, 0.5, 0.1},
wall_bottom = {-0.1, -0.5, -0.1, 0.1, -0.5+0.6, 0.1},
wall_side = {-0.5, -0.1, -0.1, -0.5+0.6, 0.1, 0.1},
},
legacy_wallmounted = true,
groups = {dig_immediate=3,not_in_creative_inventory=1},
drop = '"mesecons_torch:mesecon_torch_on" 1',
description="Mesecon Torch",
mesecons = {receptor = {
state = mesecon.state.off,
rules = torch_get_rules
}}
})
minetest.register_node("mesecons_torch:mesecon_torch_on", {
@ -43,9 +87,13 @@ minetest.register_node("mesecons_torch:mesecon_torch_on", {
wall_side = {-0.5, -0.1, -0.1, -0.5+0.6, 0.1, 0.1},
},
legacy_wallmounted = true,
groups = {dig_immediate=3, mesecon = 2},
groups = {dig_immediate=3},
light_source = LIGHT_MAX-5,
description="Mesecon Torch",
mesecons = {receptor = {
state = mesecon.state.on,
rules = torch_get_rules
}}
})
minetest.register_abm({
@ -53,70 +101,24 @@ minetest.register_abm({
interval = 1,
chance = 1,
action = function(pos, node, active_object_count, active_object_count_wider)
local rules=mesecon.torch_get_rules(minetest.env:get_node(pos).param2)
local pa = mesecon.torch_get_input_rules(node.param2)
local node = minetest.env:get_node(pos)
local pa = torch_get_input_rules(node)
local postc = {x=pos.x-pa.x, y=pos.y-pa.y, z=pos.z-pa.z}
if mesecon:is_power_on(postc) then
if node.name ~= "mesecons_torch:mesecon_torch_off" then
minetest.env:add_node(pos, {name="mesecons_torch:mesecon_torch_off",param2=node.param2})
mesecon:receptor_off(pos, rules_string)
mesecon:receptor_off(pos, torch_get_rules(node))
end
else
if node.name ~= "mesecons_torch:mesecon_torch_on" then
minetest.env:add_node(pos, {name="mesecons_torch:mesecon_torch_on",param2=node.param2})
mesecon:receptor_on(pos, rules_string)
mesecon:receptor_on(pos, torch_get_rules(node))
end
end
end
})
mesecon.torch_get_rules = function(param2)
local rules=mesecon:get_rules("mesecontorch")
if param2 == 5 then
rules=mesecon:rotate_rules_right(rules)
elseif param2 == 2 then
rules=mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules)) --180 degrees
elseif param2 == 4 then
rules=mesecon:rotate_rules_left(rules)
elseif param2 == 1 then
rules=mesecon:rotate_rules_down(rules)
elseif param2 == 0 then
rules=mesecon:rotate_rules_up(rules)
end
return rules
end
mesecon.torch_get_input_rules = function(param2)
local rules = {x=0, y=0, z=0}
if param2 == 4 then
rules.z = -2
elseif param2 == 2 then
rules.x = -2
elseif param2 == 5 then
rules.z = 2
elseif param2 == 3 then
rules.x = 2
elseif param2 == 1 then
rules.y = 2
elseif param2 == 0 then
rules.y = -2
end
return rules
end
mesecon:add_rules("mesecontorch",
{{x=1, y=0, z=0},
{x=0, y=0, z=1},
{x=0, y=0, z=-1},
{x=0, y=1, z=0},
{x=0, y=-1, z=0}})
mesecon:add_receptor_node("mesecons_torch:mesecon_torch_on", nil, mesecon.torch_get_rules)
mesecon:add_receptor_node_off("mesecons_torch:mesecon_torch_off", nil, mesecon.torch_get_rules)
mesecon:register_effector("mesecons_torch:mesecon_torch_on","mesecons_torch:mesecon_torch_off", nil, mesecon.torch_get_input_rules)
-- Param2 Table (Block Attached To)
-- 5 = z-1
-- 3 = x-1

59
mesecons_walllever/init.lua
View File

@ -1,4 +1,6 @@
-- WALL LEVER
-- Basically a switch that can be attached to a wall
-- Powers the block 2 nodes behind (using a receiver)
minetest.register_node("mesecons_walllever:wall_lever_off", {
drawtype = "nodebox",
tiles = {
@ -27,8 +29,16 @@ minetest.register_node("mesecons_walllever:wall_lever_off", {
{ -2/16, -1/16, 3/16, 2/16, 1/16, 4/16 }, -- the lever "hinge"
{ -1/16, -8/16, 4/16, 1/16, 0, 6/16 }} -- the lever itself.
},
groups = {dig_immediate=2, mesecon = 3, mesecon_needs_receiver = 1},
groups = {dig_immediate=2, mesecon_needs_receiver = 1},
description="Lever",
on_punch = function (pos, node)
mesecon:swap_node(pos, "mesecons_walllever:wall_lever_on")
mesecon:receptor_on(pos, mesecon.rules.buttonlike_get(node))
end,
mesecons = {receptor = {
rules = mesecon.rules.buttonlike_get,
state = mesecon.state.off
}}
})
minetest.register_node("mesecons_walllever:wall_lever_on", {
drawtype = "nodebox",
@ -58,22 +68,19 @@ minetest.register_node("mesecons_walllever:wall_lever_on", {
{ -2/16, -1/16, 3/16, 2/16, 1/16, 4/16 }, -- the lever "hinge"
{ -1/16, 0, 4/16, 1/16, 8/16, 6/16 }} -- the lever itself.
},
groups = {dig_immediate=2,not_in_creative_inventory=1, mesecon = 3, mesecon_needs_receiver = 1},
groups = {dig_immediate = 2, not_in_creative_inventory = 1, mesecon_needs_receiver = 1},
drop = '"mesecons_walllever:wall_lever_off" 1',
description="Lever",
on_punch = function (pos, node)
mesecon:swap_node(pos, "mesecons_walllever:wall_lever_off")
mesecon:receptor_off(pos, mesecon.rules.buttonlike_get(node))
end,
mesecons = {receptor = {
rules = mesecon.rules.buttonlike_get,
state = mesecon.state.on
}}
})
minetest.register_on_punchnode(function(pos, node, puncher)
if node.name == "mesecons_walllever:wall_lever_off" then
minetest.env:add_node(pos, {name="mesecons_walllever:wall_lever_on",param2=node.param2})
mesecon:receptor_on(pos, mesecon.walllever_get_rules(node.param2))
end
if node.name == "mesecons_walllever:wall_lever_on" then
minetest.env:add_node(pos, {name="mesecons_walllever:wall_lever_off",param2=node.param2})
mesecon:receptor_off(pos, mesecon.walllever_get_rules(node.param2))
end
end)
minetest.register_craft({
output = '"mesecons_walllever:wall_lever_off" 2',
recipe = {
@ -82,29 +89,3 @@ minetest.register_craft({
{'"default:stick"'},
}
})
mesecon:add_rules("walllever", {
{x = 1, y = 0, z = 0},
{x = 1, y = 1, z = 0},
{x = 1, y =-1, z = 0},
{x = 1, y =-1, z = 1},
{x = 1, y =-1, z =-1},
{x = 2, y = 0, z = 0},})
mesecon.walllever_get_rules = function(param2)
local rules=mesecon:get_rules("walllever")
if param2 == 2 then
rules=mesecon:rotate_rules_left(rules)
end
if param2 == 3 then
rules=mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
end
if param2 == 0 then
rules=mesecon:rotate_rules_right(rules)
end
return rules
end
mesecon:add_receptor_node("mesecons_walllever:wall_lever_on", nil, mesecon.walllever_get_rules)
mesecon:add_receptor_node_off("mesecons_walllever:wall_lever_off", nil, mesecon.walllever_get_rules)