forked from Mirrorlandia_minetest/mesecons
Compare commits
1 Commits
master
...
numzero-fi
| Author | SHA1 | Date | |
|---|---|---|---|
|
7888566b2f |
15
.github/workflows/check-release.yml
vendored
15
.github/workflows/check-release.yml
vendored
@ -1,15 +0,0 @@
|
||||
on: [push, pull_request]
|
||||
name: Check & Release
|
||||
|
||||
jobs:
|
||||
lint:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@main
|
||||
- name: apt
|
||||
run: sudo apt-get install -y luarocks
|
||||
- name: luacheck install
|
||||
run: luarocks install --local luacheck
|
||||
- name: luacheck run
|
||||
run: $HOME/.luarocks/bin/luacheck ./
|
||||
2
.gitignore
vendored
2
.gitignore
vendored
@ -1,3 +1 @@
|
||||
*~
|
||||
*.patch
|
||||
*.diff
|
||||
|
||||
36
.luacheckrc
36
.luacheckrc
@ -1,36 +0,0 @@
|
||||
std = "lua51c"
|
||||
|
||||
ignore = {
|
||||
"21/_+", -- Unused variable, except "_", "__", etc.
|
||||
"213", -- Unused loop variable
|
||||
"421", -- Shadowing a local variable
|
||||
"422", -- Shadowing an argument
|
||||
"423", -- Shadowing a loop variable
|
||||
"431", -- Shadowing an upvalue
|
||||
"432", -- Shadowing an upvalue argument
|
||||
"433", -- Shadowing an upvalue loop variable
|
||||
"542", -- Empty if branch
|
||||
}
|
||||
|
||||
max_line_length = 200
|
||||
|
||||
read_globals = {
|
||||
"default",
|
||||
"digiline",
|
||||
"doors",
|
||||
"dump",
|
||||
"jit",
|
||||
"minetest",
|
||||
"screwdriver",
|
||||
"string.split",
|
||||
"table.copy",
|
||||
"table.insert_all",
|
||||
"vector",
|
||||
"VoxelArea",
|
||||
}
|
||||
|
||||
globals = {"mesecon"}
|
||||
|
||||
files["mesecons/actionqueue.lua"] = {
|
||||
globals = {"minetest.registered_globalsteps"},
|
||||
}
|
||||
@ -1,12 +1,6 @@
|
||||
The LGPLv3 applies to all code in this project.
|
||||
The CC-BY-SA-3.0 license applies to textures and any other content in this project which is not source code.
|
||||
|
||||
The file mesecons_detector/textures/mesecons_detector_side.png is an unmodified copy of
|
||||
"default_steel_block.png" by Jean-Patrick Guerrero <https://github.com/kilbith>, which can be found at
|
||||
<https://github.com/minetest/minetest_game/blob/9528c0f8b93d6934930e99c3c116df275fb0e4bc/mods/default/textures/default_steel_block.png>.
|
||||
"default_steel_block.png" is licensed under a CC BY-SA 3.0 license. This license can be found later in this document, and can also be found at
|
||||
<https://creativecommons.org/licenses/by-sa/3.0/>. The artwork is reportedly copyright (C) 2010-2018 kilbith.
|
||||
|
||||
=================================================================
|
||||
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
|
||||
10
README.md
10
README.md
@ -12,9 +12,9 @@ MESECONS by Jeija and contributors
|
||||
|
||||
Mezzee-what?
|
||||
------------
|
||||
[Mesecons](https://mesecons.net/)! They're yellow, they're conductive, and they'll add a whole new dimension to Minetest's gameplay.
|
||||
[Mesecons](http://mesecons.net/)! They're yellow, they're conductive, and they'll add a whole new dimension to Minetest's gameplay.
|
||||
|
||||
Mesecons is a mod for [Minetest](https://www.minetest.net/) that implements a ton of items related to digital circuitry, such as wires, buttons, lights, and even programmable controllers. Among other things, there are also pistons, solar panels, pressure plates, and note blocks.
|
||||
Mesecons is a mod for [Minetest](http://minetest.net/) that implements a ton of items related to digital circuitry, such as wires, buttons, lights, and even programmable controllers. Among other things, there are also pistons, solar panels, pressure plates, and note blocks.
|
||||
|
||||
Mesecons has a similar goal to Redstone in Minecraft, but works in its own way, with different rules and mechanics.
|
||||
|
||||
@ -74,10 +74,8 @@ There are also a whole bunch of other people helping with everything from code t
|
||||
|
||||
Alright, how can I use it?
|
||||
--------------------------
|
||||
All textures in this project are licensed under the CC-BY-SA 3.0 (Creative Commons Attribution-ShareAlike 3.0 Generic).
|
||||
That means you can distribute and remix them as much as you want to, under the condition that you give credit to the authors and the project, and that if you remix and release them, they must be under the same or similar license to this one.
|
||||
All textures in this project are licensed under the CC-BY-SA 3.0 (Creative Commons Attribution-ShareAlike 3.0 Generic). That means you can distribute and remix them as much as you want to, under the condition that you give credit to the authors and the project, and that if you remix and release them, they must be under the same or similar license to this one.
|
||||
|
||||
All code in this project is licensed under the LGPL version 3.
|
||||
That means you have unlimited freedom to distribute and modify the work however you see fit, provided that if you decide to distribute it or any modified versions of it, you must also use the same license. The LGPL also grants the additional freedom to write extensions for the software and distribute them without the extensions being subject to the terms of the LGPL, although the software itself retains its license.
|
||||
All code in this project is licensed under the LGPL version 3 or later. That means you have unlimited freedom to distribute and modify the work however you see fit, provided that if you decide to distribute it or any modified versions of it, you must also use the same license. The LGPL also grants the additional freedom to write extensions for the software and distribute them without the extensions being subject to the terms of the LGPL, although the software itself retains its license.
|
||||
|
||||
No warranty is provided, express or implied, for any part of the project.
|
||||
|
||||
@ -1,9 +1,9 @@
|
||||
{
|
||||
"name": "mesecons",
|
||||
"description": "Mesecons is a mod for Minetest that implements items related to digital circuitry: wires, buttons, lights, and programmable controllers.",
|
||||
"homepage": "https://mesecons.net",
|
||||
"authors": ["Jeija"],
|
||||
"license": "LGPL-3.0",
|
||||
"homepage": "http://mesecons.net",
|
||||
"authors": "Jeija",
|
||||
"license": "LGPL-3.0+",
|
||||
"keywords": [
|
||||
"mesecons",
|
||||
"minetest",
|
||||
|
||||
@ -1,140 +1,96 @@
|
||||
--[[
|
||||
Mesecons uses something it calls an ActionQueue.
|
||||
mesecon.queue.actions={} -- contains all ActionQueue actions
|
||||
|
||||
The ActionQueue holds functions and actions.
|
||||
Functions are added on load time with a specified name.
|
||||
Actions are preserved over server restarts.
|
||||
|
||||
Each action consists of a position, the name of an added function to be called,
|
||||
the params that should be used in this function call (additionally to the pos),
|
||||
the time after which it should be executed, an optional overwritecheck and a
|
||||
priority.
|
||||
|
||||
If time = 0, the action will be executed in the next globalstep, otherwise the
|
||||
earliest globalstep when it will be executed is the after next globalstep.
|
||||
|
||||
It is guaranteed, that for two actions ac1, ac2 where ac1 ~= ac2,
|
||||
ac1.time == ac2.time, ac1.priority == ac2.priority and ac1 was added earlier
|
||||
than ac2, ac1 will be executed before ac2 (but in the same globalstep).
|
||||
|
||||
Note: Do not pass references in params, as they can not be preserved.
|
||||
|
||||
Also note: Some of the guarantees here might be dropped at some time.
|
||||
]]
|
||||
|
||||
|
||||
-- localize for speed
|
||||
local queue = mesecon.queue
|
||||
|
||||
queue.actions = {} -- contains all ActionQueue actions
|
||||
|
||||
function queue:add_function(name, func)
|
||||
self.funcs[name] = func
|
||||
function mesecon.queue:add_function(name, func)
|
||||
mesecon.queue.funcs[name] = func
|
||||
end
|
||||
|
||||
-- If add_action with twice the same overwritecheck and same position are called, the first one is overwritten
|
||||
-- use overwritecheck nil to never overwrite, but just add the event to the queue
|
||||
-- priority specifies the order actions are executed within one globalstep, highest first
|
||||
-- should be between 0 and 1
|
||||
function queue:add_action(pos, func, params, time, overwritecheck, priority)
|
||||
function mesecon.queue:add_action(pos, func, params, time, overwritecheck, priority)
|
||||
-- Create Action Table:
|
||||
time = time or 0 -- time <= 0 --> execute, time > 0 --> wait time until execution
|
||||
priority = priority or 1
|
||||
local action = {
|
||||
pos = mesecon.tablecopy(pos),
|
||||
func = func,
|
||||
params = mesecon.tablecopy(params or {}),
|
||||
time = time,
|
||||
owcheck = (overwritecheck and mesecon.tablecopy(overwritecheck)) or nil,
|
||||
priority = priority
|
||||
}
|
||||
local action = { pos=mesecon.tablecopy(pos),
|
||||
func=func,
|
||||
params=mesecon.tablecopy(params or {}),
|
||||
time=time,
|
||||
owcheck=(overwritecheck and mesecon.tablecopy(overwritecheck)) or nil,
|
||||
priority=priority}
|
||||
|
||||
-- check if old action has to be overwritten / removed:
|
||||
if overwritecheck then
|
||||
for i, ac in ipairs(self.actions) do
|
||||
if vector.equals(pos, ac.pos)
|
||||
and mesecon.cmpAny(overwritecheck, ac.owcheck) then
|
||||
-- remove the old action
|
||||
table.remove(self.actions, i)
|
||||
local toremove = nil
|
||||
-- Otherwise, add the action to the queue
|
||||
if overwritecheck then -- check if old action has to be overwritten / removed:
|
||||
for i, ac in ipairs(mesecon.queue.actions) do
|
||||
if(vector.equals(pos, ac.pos)
|
||||
and mesecon.cmpAny(overwritecheck, ac.owcheck)) then
|
||||
toremove = i
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
table.insert(self.actions, action)
|
||||
if (toremove ~= nil) then
|
||||
table.remove(mesecon.queue.actions, toremove)
|
||||
end
|
||||
|
||||
table.insert(mesecon.queue.actions, action)
|
||||
end
|
||||
|
||||
-- execute the stored functions on a globalstep
|
||||
-- if however, the pos of a function is not loaded (get_node_or_nil == nil), do NOT execute the function
|
||||
-- this makes sure that resuming mesecons circuits when restarting minetest works fine (hm, where do we do this?)
|
||||
-- this makes sure that resuming mesecons circuits when restarting minetest works fine
|
||||
-- However, even that does not work in some cases, that's why we delay the time the globalsteps
|
||||
-- start to be execute by 4 seconds
|
||||
-- start to be execute by 5 seconds
|
||||
local get_highest_priority = function (actions)
|
||||
local highestp = -1
|
||||
local highesti
|
||||
for i, ac in ipairs(actions) do
|
||||
if ac.priority > highestp then
|
||||
highestp = ac.priority
|
||||
highesti = i
|
||||
end
|
||||
end
|
||||
|
||||
local function globalstep_func(dtime)
|
||||
local actions = queue.actions
|
||||
-- split into two categories:
|
||||
-- actions_now: actions to execute now
|
||||
-- queue.actions: actions to execute later
|
||||
local actions_now = {}
|
||||
queue.actions = {}
|
||||
return highesti
|
||||
end
|
||||
|
||||
for _, ac in ipairs(actions) do
|
||||
local m_time = 0
|
||||
local resumetime = mesecon.setting("resumetime", 4)
|
||||
minetest.register_globalstep(function (dtime)
|
||||
m_time = m_time + dtime
|
||||
-- don't even try if server has not been running for XY seconds; resumetime = time to wait
|
||||
-- after starting the server before processing the ActionQueue, don't set this too low
|
||||
if (m_time < resumetime) then return end
|
||||
local actions = mesecon.tablecopy(mesecon.queue.actions)
|
||||
local actions_now={}
|
||||
|
||||
mesecon.queue.actions = {}
|
||||
|
||||
-- sort actions into two categories:
|
||||
-- those toexecute now (actions_now) and those to execute later (mesecon.queue.actions)
|
||||
for i, ac in ipairs(actions) do
|
||||
if ac.time > 0 then
|
||||
-- action ac is to be executed later
|
||||
-- ~> insert into queue.actions
|
||||
ac.time = ac.time - dtime
|
||||
table.insert(queue.actions, ac)
|
||||
ac.time = ac.time - dtime -- executed later
|
||||
table.insert(mesecon.queue.actions, ac)
|
||||
else
|
||||
-- action ac is to be executed now
|
||||
-- ~> insert into actions_now
|
||||
table.insert(actions_now, ac)
|
||||
end
|
||||
end
|
||||
|
||||
-- stable-sort the executed actions after their priority
|
||||
-- some constructions might depend on the execution order, hence we first
|
||||
-- execute the actions that had a lower index in actions_now
|
||||
local old_action_order = {}
|
||||
for i, ac in ipairs(actions_now) do
|
||||
old_action_order[ac] = i
|
||||
while(#actions_now > 0) do -- execute highest priorities first, until all are executed
|
||||
local hp = get_highest_priority(actions_now)
|
||||
mesecon.queue:execute(actions_now[hp])
|
||||
table.remove(actions_now, hp)
|
||||
end
|
||||
table.sort(actions_now, function(ac1, ac2)
|
||||
if ac1.priority ~= ac2.priority then
|
||||
return ac1.priority > ac2.priority
|
||||
else
|
||||
return old_action_order[ac1] < old_action_order[ac2]
|
||||
end
|
||||
end)
|
||||
end)
|
||||
|
||||
-- execute highest priorities first, until all are executed
|
||||
for _, ac in ipairs(actions_now) do
|
||||
queue:execute(ac)
|
||||
end
|
||||
end
|
||||
|
||||
-- delay the time the globalsteps start to be execute by 4 seconds
|
||||
do
|
||||
local m_time = 0
|
||||
local resumetime = mesecon.setting("resumetime", 4)
|
||||
local globalstep_func_index = #minetest.registered_globalsteps + 1
|
||||
|
||||
minetest.register_globalstep(function(dtime)
|
||||
m_time = m_time + dtime
|
||||
-- don't even try if server has not been running for XY seconds; resumetime = time to wait
|
||||
-- after starting the server before processing the ActionQueue, don't set this too low
|
||||
if m_time < resumetime then
|
||||
return
|
||||
end
|
||||
-- replace this globalstep function
|
||||
minetest.registered_globalsteps[globalstep_func_index] = globalstep_func
|
||||
end)
|
||||
end
|
||||
|
||||
function queue:execute(action)
|
||||
function mesecon.queue:execute(action)
|
||||
-- ignore if action queue function name doesn't exist,
|
||||
-- (e.g. in case the action queue savegame was written by an old mesecons version)
|
||||
if self.funcs[action.func] then
|
||||
self.funcs[action.func](action.pos, unpack(action.params))
|
||||
if mesecon.queue.funcs[action.func] then
|
||||
mesecon.queue.funcs[action.func](action.pos, unpack(action.params))
|
||||
end
|
||||
end
|
||||
|
||||
@ -142,8 +98,8 @@ end
|
||||
-- Store and read the ActionQueue to / from a file
|
||||
-- so that upcoming actions are remembered when the game
|
||||
-- is restarted
|
||||
queue.actions = mesecon.file2table("mesecon_actionqueue")
|
||||
mesecon.queue.actions = mesecon.file2table("mesecon_actionqueue")
|
||||
|
||||
minetest.register_on_shutdown(function()
|
||||
mesecon.table2file("mesecon_actionqueue", queue.actions)
|
||||
mesecon.table2file("mesecon_actionqueue", mesecon.queue.actions)
|
||||
end)
|
||||
|
||||
1
mesecons/depends.txt
Normal file
1
mesecons/depends.txt
Normal file
@ -0,0 +1 @@
|
||||
default
|
||||
@ -1,62 +0,0 @@
|
||||
|
||||
-- a simple first-in-first-out queue
|
||||
-- very similar to the one in https://github.com/minetest/minetest/pull/7683
|
||||
|
||||
local fifo_queue = {}
|
||||
|
||||
local metatable = {__index = fifo_queue}
|
||||
|
||||
-- creates a new empty queue
|
||||
function fifo_queue.new()
|
||||
local q = {n_in = 0, n_out = 0, i_out = 1, buf_in = {}, buf_out = {}}
|
||||
setmetatable(q, metatable)
|
||||
return q
|
||||
end
|
||||
|
||||
-- adds an element to the queue
|
||||
function fifo_queue.add(self, v)
|
||||
local n = self.n_in + 1
|
||||
self.n_in = n
|
||||
self.buf_in[n] = v
|
||||
end
|
||||
|
||||
-- removes and returns the next element, or nil of empty
|
||||
function fifo_queue.take(self)
|
||||
local i_out = self.i_out
|
||||
if i_out <= self.n_out then
|
||||
local v = self.buf_out[i_out]
|
||||
self.i_out = i_out + 1
|
||||
self.buf_out[i_out] = true
|
||||
return v
|
||||
end
|
||||
|
||||
-- buf_out is empty, try to swap
|
||||
self.i_out = 1
|
||||
self.n_out = 0
|
||||
if self.n_in == 0 then
|
||||
return nil -- empty
|
||||
end
|
||||
|
||||
-- swap
|
||||
self.n_out = self.n_in
|
||||
self.n_in = 0
|
||||
self.buf_out, self.buf_in = self.buf_in, self.buf_out
|
||||
|
||||
local v = self.buf_out[1]
|
||||
self.i_out = 2
|
||||
self.buf_out[1] = true
|
||||
return v
|
||||
end
|
||||
|
||||
-- returns whether the queue is empty
|
||||
function fifo_queue.is_empty(self)
|
||||
return self.n_out == self.i_out + 1 and self.n_in == 0
|
||||
end
|
||||
|
||||
-- returns stuff for iteration in a for loop, like pairs
|
||||
-- adding new elements while iterating is no problem
|
||||
function fifo_queue.iter(self)
|
||||
return fifo_queue.take, self, nil
|
||||
end
|
||||
|
||||
return fifo_queue
|
||||
@ -11,7 +11,7 @@
|
||||
|
||||
-- RECEPTORS
|
||||
-- mesecon.is_receptor(nodename) --> Returns true if nodename is a receptor
|
||||
-- mesecon.is_receptor_on(nodename) --> Returns true if nodename is an receptor with state = mesecon.state.on
|
||||
-- mesecon.is_receptor_on(nodename --> Returns true if nodename is an receptor with state = mesecon.state.on
|
||||
-- mesecon.is_receptor_off(nodename) --> Returns true if nodename is an receptor with state = mesecon.state.off
|
||||
-- mesecon.receptor_get_rules(node) --> Returns the rules of the receptor (mesecon.rules.default if none specified)
|
||||
|
||||
@ -46,9 +46,6 @@
|
||||
-- mesecon.rotate_rules_down(rules)
|
||||
-- These functions return rules that have been rotated in the specific direction
|
||||
|
||||
-- See fifo_queue.lua for documentation.
|
||||
mesecon.fifo_queue = dofile(minetest.get_modpath("mesecons").."/fifo_queue.lua")
|
||||
|
||||
-- General
|
||||
function mesecon.get_effector(nodename)
|
||||
if minetest.registered_nodes[nodename]
|
||||
@ -95,8 +92,8 @@ function mesecon.get_any_inputrules(node)
|
||||
end
|
||||
|
||||
function mesecon.get_any_rules(node)
|
||||
return mesecon.merge_rule_sets(mesecon.get_any_inputrules(node),
|
||||
mesecon.get_any_outputrules(node))
|
||||
return mesecon.mergetable(mesecon.get_any_inputrules(node) or {},
|
||||
mesecon.get_any_outputrules(node) or {})
|
||||
end
|
||||
|
||||
-- Receptors
|
||||
@ -319,7 +316,7 @@ function mesecon.get_conductor_on(node_off, rulename)
|
||||
return conductor.states[tonumber(binstate,2)+1]
|
||||
end
|
||||
end
|
||||
return nil
|
||||
return offstate
|
||||
end
|
||||
|
||||
function mesecon.get_conductor_off(node_on, rulename)
|
||||
@ -335,7 +332,7 @@ function mesecon.get_conductor_off(node_on, rulename)
|
||||
return conductor.states[tonumber(binstate,2)+1]
|
||||
end
|
||||
end
|
||||
return nil
|
||||
return onstate
|
||||
end
|
||||
|
||||
function mesecon.conductor_get_rules(node)
|
||||
@ -369,98 +366,37 @@ function mesecon.is_power_off(pos, rulename)
|
||||
return false
|
||||
end
|
||||
|
||||
-- The set of conductor states which require light updates when they change.
|
||||
local light_update_conductors
|
||||
|
||||
-- Calculate the contents of the above set if they have not been calculated.
|
||||
local function find_light_update_conductors()
|
||||
-- The expensive calculation is only done the first time.
|
||||
if light_update_conductors then return end
|
||||
|
||||
light_update_conductors = {}
|
||||
|
||||
-- Find conductors whose lighting characteristics change depending on their state.
|
||||
local checked = {}
|
||||
for name, def in pairs(minetest.registered_nodes) do
|
||||
local conductor = mesecon.get_conductor(name)
|
||||
if conductor and not checked[name] then
|
||||
-- Find the other states of the conductor besides the current one.
|
||||
local other_states
|
||||
if conductor.onstate then
|
||||
other_states = {conductor.onstate}
|
||||
elseif conductor.offstate then
|
||||
other_states = {conductor.offstate}
|
||||
else
|
||||
other_states = conductor.states
|
||||
end
|
||||
|
||||
-- Check the conductor. Other states are marked as checked.
|
||||
for _, other_state in ipairs(other_states) do
|
||||
local other_def = minetest.registered_nodes[other_state]
|
||||
if (def.paramtype == "light") ~= (other_def.paramtype == "light")
|
||||
or def.sunlight_propagates ~= other_def.sunlight_propagates
|
||||
or def.light_source ~= other_def.light_source then
|
||||
-- The light characteristics change depending on the state.
|
||||
-- The states are added to the set.
|
||||
light_update_conductors[name] = true
|
||||
for _, other_state in ipairs(other_states) do
|
||||
light_update_conductors[other_state] = true
|
||||
checked[other_state] = true
|
||||
end
|
||||
break
|
||||
end
|
||||
checked[other_state] = true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- Turn off an equipotential section starting at `pos`, which outputs in the direction of `link`.
|
||||
-- Breadth-first search. Map is abstracted away in a voxelmanip.
|
||||
-- Follow all all conductor paths replacing conductors that were already
|
||||
-- looked at, activating / changing all effectors along the way.
|
||||
function mesecon.turnon(pos, link)
|
||||
find_light_update_conductors()
|
||||
|
||||
local frontiers = mesecon.fifo_queue.new()
|
||||
frontiers:add({pos = pos, link = link})
|
||||
local pos_can_be_skipped = {}
|
||||
local frontiers = {{pos = pos, link = link}}
|
||||
|
||||
local depth = 1
|
||||
for f in frontiers:iter() do
|
||||
while frontiers[1] do
|
||||
local f = table.remove(frontiers, 1)
|
||||
local node = mesecon.get_node_force(f.pos)
|
||||
|
||||
if not node then
|
||||
-- Area does not exist; do nothing
|
||||
pos_can_be_skipped[minetest.hash_node_position(f.pos)] = true
|
||||
elseif mesecon.is_conductor(node.name) then
|
||||
elseif mesecon.is_conductor_off(node, f.link) then
|
||||
local rules = mesecon.conductor_get_rules(node)
|
||||
|
||||
if mesecon.is_conductor_off(node, f.link) then
|
||||
-- Call turnon on neighbors
|
||||
for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
|
||||
local np = vector.add(f.pos, r)
|
||||
if not pos_can_be_skipped[minetest.hash_node_position(np)] then
|
||||
for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
|
||||
frontiers:add({pos = np, link = l})
|
||||
end
|
||||
end
|
||||
-- Call turnon on neighbors
|
||||
for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
|
||||
local np = vector.add(f.pos, r)
|
||||
for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
|
||||
table.insert(frontiers, {pos = np, link = l})
|
||||
end
|
||||
|
||||
mesecon.swap_node_force(f.pos, mesecon.get_conductor_on(node, f.link), light_update_conductors[node.name] ~= nil)
|
||||
end
|
||||
|
||||
-- Only conductors with flat rules can be reliably skipped later
|
||||
if not rules[1] or rules[1].x then
|
||||
pos_can_be_skipped[minetest.hash_node_position(f.pos)] = true
|
||||
end
|
||||
mesecon.swap_node_force(f.pos, mesecon.get_conductor_on(node, f.link))
|
||||
elseif mesecon.is_effector(node.name) then
|
||||
mesecon.changesignal(f.pos, node, f.link, mesecon.state.on, depth)
|
||||
if mesecon.is_effector_off(node.name) then
|
||||
mesecon.activate(f.pos, node, f.link, depth)
|
||||
end
|
||||
else
|
||||
pos_can_be_skipped[minetest.hash_node_position(f.pos)] = true
|
||||
end
|
||||
depth = depth + 1
|
||||
end
|
||||
@ -483,51 +419,37 @@ end
|
||||
-- depth = indicates order in which signals wire fired, higher is later
|
||||
-- }
|
||||
function mesecon.turnoff(pos, link)
|
||||
find_light_update_conductors()
|
||||
|
||||
local frontiers = mesecon.fifo_queue.new()
|
||||
frontiers:add({pos = pos, link = link})
|
||||
local frontiers = {{pos = pos, link = link}}
|
||||
local signals = {}
|
||||
local pos_can_be_skipped = {}
|
||||
|
||||
local depth = 1
|
||||
for f in frontiers:iter() do
|
||||
while frontiers[1] do
|
||||
local f = table.remove(frontiers, 1)
|
||||
local node = mesecon.get_node_force(f.pos)
|
||||
|
||||
if not node then
|
||||
-- Area does not exist; do nothing
|
||||
pos_can_be_skipped[minetest.hash_node_position(f.pos)] = true
|
||||
elseif mesecon.is_conductor(node.name) then
|
||||
elseif mesecon.is_conductor_on(node, f.link) then
|
||||
local rules = mesecon.conductor_get_rules(node)
|
||||
for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
|
||||
local np = vector.add(f.pos, r)
|
||||
|
||||
if mesecon.is_conductor_on(node, f.link) then
|
||||
for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
|
||||
local np = vector.add(f.pos, r)
|
||||
|
||||
if not pos_can_be_skipped[minetest.hash_node_position(np)] then
|
||||
-- Check if an onstate receptor is connected. If that is the case,
|
||||
-- abort this turnoff process by returning false. `receptor_off` will
|
||||
-- discard all the changes that we made in the voxelmanip:
|
||||
if mesecon.rules_link_rule_all_inverted(f.pos, r)[1] then
|
||||
if mesecon.is_receptor_on(mesecon.get_node_force(np).name) then
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
-- Call turnoff on neighbors
|
||||
for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
|
||||
frontiers:add({pos = np, link = l})
|
||||
end
|
||||
-- Check if an onstate receptor is connected. If that is the case,
|
||||
-- abort this turnoff process by returning false. `receptor_off` will
|
||||
-- discard all the changes that we made in the voxelmanip:
|
||||
for _, l in ipairs(mesecon.rules_link_rule_all_inverted(f.pos, r)) do
|
||||
if mesecon.is_receptor_on(mesecon.get_node_force(np).name) then
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
mesecon.swap_node_force(f.pos, mesecon.get_conductor_off(node, f.link), light_update_conductors[node.name] ~= nil)
|
||||
-- Call turnoff on neighbors
|
||||
for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
|
||||
table.insert(frontiers, {pos = np, link = l})
|
||||
end
|
||||
end
|
||||
|
||||
-- Only conductors with flat rules can be reliably skipped later
|
||||
if not rules[1] or rules[1].x then
|
||||
pos_can_be_skipped[minetest.hash_node_position(f.pos)] = true
|
||||
end
|
||||
mesecon.swap_node_force(f.pos, mesecon.get_conductor_off(node, f.link))
|
||||
elseif mesecon.is_effector(node.name) then
|
||||
table.insert(signals, {
|
||||
pos = f.pos,
|
||||
@ -535,8 +457,6 @@ function mesecon.turnoff(pos, link)
|
||||
link = f.link,
|
||||
depth = depth
|
||||
})
|
||||
else
|
||||
pos_can_be_skipped[minetest.hash_node_position(f.pos)] = true
|
||||
end
|
||||
depth = depth + 1
|
||||
end
|
||||
|
||||
@ -11,4 +11,4 @@ local old_forceloaded_blocks = mesecon.file2table("mesecon_forceloaded")
|
||||
for hash, _ in pairs(old_forceloaded_blocks) do
|
||||
minetest.forceload_free_block(unhash_blockpos(hash))
|
||||
end
|
||||
os.remove(minetest.get_worldpath().."/mesecon_forceloaded")
|
||||
os.remove(minetest.get_worldpath()..DIR_DELIM.."mesecon_forceloaded")
|
||||
|
||||
@ -1,3 +0,0 @@
|
||||
name = mesecons
|
||||
# default is an optional dependency as some mods may expect it as a transitory
|
||||
# dependency when they depend on mesecons.
|
||||
@ -11,7 +11,7 @@ minetest.register_node("mesecons:mesecon_off", {
|
||||
fixed = {-0.5, -0.5, -0.5, 0.5, -0.45, 0.5},
|
||||
},
|
||||
groups = {dig_immediate=3, mesecon=1, mesecon_conductor_craftable=1},
|
||||
description="Mesecons",
|
||||
description="Mesecons",
|
||||
mesecons = {conductor={
|
||||
state = mesecon.state.off,
|
||||
onstate = "mesecons:mesecon_on"
|
||||
|
||||
@ -16,9 +16,9 @@ mesecon.rules.default = {
|
||||
{x = 0, y = -1, z = -1},
|
||||
}
|
||||
|
||||
mesecon.rules.floor = mesecon.merge_rule_sets(mesecon.rules.default, {{x = 0, y = -1, z = 0}})
|
||||
mesecon.rules.floor = mesecon.mergetable(mesecon.rules.default, {{x = 0, y = -1, z = 0}})
|
||||
|
||||
mesecon.rules.pplate = mesecon.merge_rule_sets(mesecon.rules.floor, {{x = 0, y = -2, z = 0}})
|
||||
mesecon.rules.pplate = mesecon.mergetable(mesecon.rules.floor, {{x = 0, y = -2, z = 0}})
|
||||
|
||||
mesecon.rules.buttonlike = {
|
||||
{x = 1, y = 0, z = 0},
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
mesecon.on_placenode = function(pos, node)
|
||||
mesecon.execute_autoconnect_hooks_now(pos, node)
|
||||
node = minetest.get_node(pos) -- Update the node in case it was just changed.
|
||||
|
||||
-- Receptors: Send on signal when active
|
||||
if mesecon.is_receptor_on(node.name) then
|
||||
@ -12,20 +11,18 @@ mesecon.on_placenode = function(pos, node)
|
||||
-- Conductors: Send turnon signal when powered or replace by respective offstate conductor
|
||||
-- if placed conductor is an onstate one
|
||||
if mesecon.is_conductor(node.name) then
|
||||
local conductor = mesecon.get_conductor(node.name)
|
||||
if conductor.state ~= mesecon.state.off then
|
||||
-- Turn the conductor off.
|
||||
node.name = conductor.offstate or conductor.states[1]
|
||||
minetest.swap_node(pos, node)
|
||||
end
|
||||
local sources = mesecon.is_powered(pos)
|
||||
if sources then
|
||||
mesecon.vm_begin()
|
||||
-- also call receptor_on if itself is powered already, so that neighboring
|
||||
-- conductors will be activated (when pushing an on-conductor with a piston)
|
||||
for _, s in ipairs(sources) do
|
||||
local rule = vector.subtract(s, pos)
|
||||
local rule = vector.subtract(pos, s)
|
||||
mesecon.turnon(pos, rule)
|
||||
end
|
||||
mesecon.vm_commit()
|
||||
--mesecon.receptor_on (pos, mesecon.conductor_get_rules(node))
|
||||
elseif mesecon.is_conductor_on(node) then
|
||||
node.name = mesecon.get_conductor_off(node)
|
||||
minetest.swap_node(pos, node)
|
||||
end
|
||||
end
|
||||
|
||||
@ -66,7 +63,7 @@ mesecon.on_dignode = function(pos, node)
|
||||
mesecon.execute_autoconnect_hooks_queue(pos, node)
|
||||
end
|
||||
|
||||
function mesecon.on_blastnode(pos)
|
||||
function mesecon.on_blastnode(pos, intensity)
|
||||
local node = minetest.get_node(pos)
|
||||
minetest.remove_node(pos)
|
||||
mesecon.on_dignode(pos, node)
|
||||
|
||||
@ -6,24 +6,6 @@ function mesecon.move_node(pos, newpos)
|
||||
minetest.get_meta(pos):from_table(meta)
|
||||
end
|
||||
|
||||
-- An on_rotate callback for mesecons components.
|
||||
function mesecon.on_rotate(pos, node, _, _, new_param2)
|
||||
local new_node = {name = node.name, param1 = node.param1, param2 = new_param2}
|
||||
minetest.swap_node(pos, new_node)
|
||||
mesecon.on_dignode(pos, node)
|
||||
mesecon.on_placenode(pos, new_node)
|
||||
minetest.check_for_falling(pos)
|
||||
return true
|
||||
end
|
||||
|
||||
-- An on_rotate callback for components which stay horizontal.
|
||||
function mesecon.on_rotate_horiz(pos, node, user, mode, new_param2)
|
||||
if not minetest.global_exists("screwdriver") or mode ~= screwdriver.ROTATE_FACE then
|
||||
return false
|
||||
end
|
||||
return mesecon.on_rotate(pos, node, user, mode, new_param2)
|
||||
end
|
||||
|
||||
-- Rules rotation Functions:
|
||||
function mesecon.rotate_rules_right(rules)
|
||||
local nr = {}
|
||||
@ -72,28 +54,7 @@ function mesecon.rotate_rules_up(rules)
|
||||
end
|
||||
return nr
|
||||
end
|
||||
|
||||
-- Returns a rules getter function that returns different rules depending on the node's horizontal rotation.
|
||||
-- If param2 % 4 == 0, then the rules returned by the getter are a copy of base_rules.
|
||||
function mesecon.horiz_rules_getter(base_rules)
|
||||
local rotations = {mesecon.tablecopy(base_rules)}
|
||||
for i = 2, 4 do
|
||||
local right_rules = rotations[i - 1]
|
||||
if not right_rules[1] or right_rules[1].x then
|
||||
-- flat rules
|
||||
rotations[i] = mesecon.rotate_rules_left(right_rules)
|
||||
else
|
||||
-- not flat
|
||||
rotations[i] = {}
|
||||
for j, rules in ipairs(right_rules) do
|
||||
rotations[i][j] = mesecon.rotate_rules_left(rules)
|
||||
end
|
||||
end
|
||||
end
|
||||
return function(node)
|
||||
return rotations[node.param2 % 4 + 1]
|
||||
end
|
||||
end
|
||||
--
|
||||
|
||||
function mesecon.flattenrules(allrules)
|
||||
--[[
|
||||
@ -203,9 +164,7 @@ end
|
||||
|
||||
function mesecon.get_bit(binary,bit)
|
||||
bit = bit or 1
|
||||
local len = binary:len()
|
||||
if bit > len then return false end
|
||||
local c = len-(bit-1)
|
||||
local c = binary:len()-(bit-1)
|
||||
return binary:sub(c,c) == "1"
|
||||
end
|
||||
|
||||
@ -234,29 +193,19 @@ function mesecon.tablecopy(obj) -- deep copy
|
||||
return obj
|
||||
end
|
||||
|
||||
-- Returns whether two values are equal.
|
||||
-- In tables, keys are compared for identity but values are compared recursively.
|
||||
-- There is no protection from infinite recursion.
|
||||
function mesecon.cmpAny(t1, t2)
|
||||
if type(t1) ~= type(t2) then return false end
|
||||
if type(t1) ~= "table" then return t1 == t2 end
|
||||
if type(t1) ~= "table" and type(t2) ~= "table" then return t1 == t2 end
|
||||
|
||||
-- Check that for each key of `t1` both tables have the same value
|
||||
for i, e in pairs(t1) do
|
||||
if not mesecon.cmpAny(e, t2[i]) then return false end
|
||||
end
|
||||
|
||||
-- Check that all keys of `t2` are also keys of `t1` so were checked in the previous loop
|
||||
for i, _ in pairs(t2) do
|
||||
if t1[i] == nil then return false end
|
||||
end
|
||||
|
||||
return true
|
||||
end
|
||||
|
||||
-- Deprecated. Use `merge_tables` or `merge_rule_sets` as appropriate.
|
||||
-- does not overwrite values; number keys (ipairs) are appended, not overwritten
|
||||
function mesecon.mergetable(source, dest)
|
||||
minetest.log("warning", debug.traceback("Deprecated call to mesecon.mergetable"))
|
||||
local rval = mesecon.tablecopy(dest)
|
||||
|
||||
for k, v in pairs(source) do
|
||||
@ -269,32 +218,6 @@ function mesecon.mergetable(source, dest)
|
||||
return rval
|
||||
end
|
||||
|
||||
-- Merges several rule sets in one. Order may not be preserved. Nil arguments
|
||||
-- are ignored.
|
||||
-- The rule sets must be of the same kind (either all single-level or all two-level).
|
||||
-- The function may be changed to normalize the resulting set in some way.
|
||||
function mesecon.merge_rule_sets(...)
|
||||
local rval = {}
|
||||
for _, t in pairs({...}) do -- ignores nils automatically
|
||||
table.insert_all(rval, mesecon.tablecopy(t))
|
||||
end
|
||||
return rval
|
||||
end
|
||||
|
||||
-- Merges two tables, with entries from `replacements` taking precedence over
|
||||
-- those from `base`. Returns the new table.
|
||||
-- Values are deep-copied from either table, keys are referenced.
|
||||
-- Numerical indices aren’t handled specially.
|
||||
function mesecon.merge_tables(base, replacements)
|
||||
local ret = mesecon.tablecopy(replacements) -- these are never overriden so have to be copied in any case
|
||||
for k, v in pairs(base) do
|
||||
if ret[k] == nil then -- it could be `false`
|
||||
ret[k] = mesecon.tablecopy(v)
|
||||
end
|
||||
end
|
||||
return ret
|
||||
end
|
||||
|
||||
function mesecon.register_node(name, spec_common, spec_off, spec_on)
|
||||
spec_common.drop = spec_common.drop or name .. "_off"
|
||||
spec_common.on_blast = spec_common.on_blast or mesecon.on_blastnode
|
||||
@ -302,8 +225,8 @@ function mesecon.register_node(name, spec_common, spec_off, spec_on)
|
||||
spec_on.__mesecon_state = "on"
|
||||
spec_off.__mesecon_state = "off"
|
||||
|
||||
spec_on = mesecon.merge_tables(spec_common, spec_on);
|
||||
spec_off = mesecon.merge_tables(spec_common, spec_off);
|
||||
spec_on = mesecon.mergetable(spec_common, spec_on);
|
||||
spec_off = mesecon.mergetable(spec_common, spec_off);
|
||||
|
||||
minetest.register_node(name .. "_on", spec_on)
|
||||
minetest.register_node(name .. "_off", spec_off)
|
||||
@ -325,7 +248,7 @@ end
|
||||
-- File writing / reading utilities
|
||||
local wpath = minetest.get_worldpath()
|
||||
function mesecon.file2table(filename)
|
||||
local f = io.open(wpath.."/"..filename, "r")
|
||||
local f = io.open(wpath..DIR_DELIM..filename, "r")
|
||||
if f == nil then return {} end
|
||||
local t = f:read("*all")
|
||||
f:close()
|
||||
@ -334,7 +257,7 @@ function mesecon.file2table(filename)
|
||||
end
|
||||
|
||||
function mesecon.table2file(filename, table)
|
||||
local f = io.open(wpath.."/"..filename, "w")
|
||||
local f = io.open(wpath..DIR_DELIM..filename, "w")
|
||||
f:write(minetest.serialize(table))
|
||||
f:close()
|
||||
end
|
||||
@ -356,17 +279,15 @@ end
|
||||
--
|
||||
-- Contents of the table are:
|
||||
-- “vm” → the VoxelManipulator
|
||||
-- “va” → the VoxelArea
|
||||
-- “data” → the data array
|
||||
-- “param1” → the param1 array
|
||||
-- “param2” → the param2 array
|
||||
-- “dirty” → true if data has been modified
|
||||
--
|
||||
-- Nil if no VM-based transaction is in progress.
|
||||
local vm_cache = nil
|
||||
|
||||
-- Cache from node position hashes to nodes (represented as tables).
|
||||
local vm_node_cache = nil
|
||||
|
||||
-- Whether the current transaction will need a light update afterward.
|
||||
local vm_update_light = false
|
||||
|
||||
-- Starts a VoxelManipulator-based transaction.
|
||||
--
|
||||
-- During a VM transaction, calls to vm_get_node and vm_swap_node operate on a
|
||||
@ -375,8 +296,6 @@ local vm_update_light = false
|
||||
-- vm_abort.
|
||||
function mesecon.vm_begin()
|
||||
vm_cache = {}
|
||||
vm_node_cache = {}
|
||||
vm_update_light = false
|
||||
end
|
||||
|
||||
-- Finishes a VoxelManipulator-based transaction, freeing the VMs and map data
|
||||
@ -385,19 +304,18 @@ function mesecon.vm_commit()
|
||||
for hash, tbl in pairs(vm_cache) do
|
||||
if tbl.dirty then
|
||||
local vm = tbl.vm
|
||||
vm:write_to_map(vm_update_light)
|
||||
vm:set_data(tbl.data)
|
||||
vm:write_to_map()
|
||||
vm:update_map()
|
||||
end
|
||||
end
|
||||
vm_cache = nil
|
||||
vm_node_cache = nil
|
||||
end
|
||||
|
||||
-- Finishes a VoxelManipulator-based transaction, freeing the VMs and throwing
|
||||
-- away any modified areas.
|
||||
function mesecon.vm_abort()
|
||||
vm_cache = nil
|
||||
vm_node_cache = nil
|
||||
end
|
||||
|
||||
-- Gets the cache entry covering a position, populating it if necessary.
|
||||
@ -405,7 +323,10 @@ local function vm_get_or_create_entry(pos)
|
||||
local hash = hash_blockpos(pos)
|
||||
local tbl = vm_cache[hash]
|
||||
if not tbl then
|
||||
tbl = {vm = minetest.get_voxel_manip(pos, pos), dirty = false}
|
||||
local vm = minetest.get_voxel_manip(pos, pos)
|
||||
local min_pos, max_pos = vm:get_emerged_area()
|
||||
local va = VoxelArea:new{MinEdge = min_pos, MaxEdge = max_pos}
|
||||
tbl = {vm = vm, va = va, data = vm:get_data(), param1 = vm:get_light_data(), param2 = vm:get_param2_data(), dirty = false}
|
||||
vm_cache[hash] = tbl
|
||||
end
|
||||
return tbl
|
||||
@ -414,34 +335,25 @@ end
|
||||
-- Gets the node at a given position during a VoxelManipulator-based
|
||||
-- transaction.
|
||||
function mesecon.vm_get_node(pos)
|
||||
local hash = minetest.hash_node_position(pos)
|
||||
local node = vm_node_cache[hash]
|
||||
if not node then
|
||||
node = vm_get_or_create_entry(pos).vm:get_node_at(pos)
|
||||
vm_node_cache[hash] = node
|
||||
local tbl = vm_get_or_create_entry(pos)
|
||||
local index = tbl.va:indexp(pos)
|
||||
local node_value = tbl.data[index]
|
||||
if node_value == core.CONTENT_IGNORE then
|
||||
return nil
|
||||
else
|
||||
local node_param1 = tbl.param1[index]
|
||||
local node_param2 = tbl.param2[index]
|
||||
return {name = minetest.get_name_from_content_id(node_value), param1 = node_param1, param2 = node_param2}
|
||||
end
|
||||
return node.name ~= "ignore" and {name = node.name, param1 = node.param1, param2 = node.param2} or nil
|
||||
end
|
||||
|
||||
-- Sets a node’s name during a VoxelManipulator-based transaction.
|
||||
--
|
||||
-- Existing param1, param2, and metadata are left alone.
|
||||
--
|
||||
-- The swap will necessitate a light update unless update_light equals false.
|
||||
function mesecon.vm_swap_node(pos, name, update_light)
|
||||
-- If one node needs a light update, all VMs should use light updates to
|
||||
-- prevent newly calculated light from being overwritten by other VMs.
|
||||
vm_update_light = vm_update_light or update_light ~= false
|
||||
|
||||
function mesecon.vm_swap_node(pos, name)
|
||||
local tbl = vm_get_or_create_entry(pos)
|
||||
local hash = minetest.hash_node_position(pos)
|
||||
local node = vm_node_cache[hash]
|
||||
if not node then
|
||||
node = tbl.vm:get_node_at(pos)
|
||||
vm_node_cache[hash] = node
|
||||
end
|
||||
node.name = name
|
||||
tbl.vm:set_node_at(pos, node)
|
||||
local index = tbl.va:indexp(pos)
|
||||
tbl.data[index] = minetest.get_content_id(name)
|
||||
tbl.dirty = true
|
||||
end
|
||||
|
||||
@ -477,11 +389,9 @@ end
|
||||
--
|
||||
-- This function can only be used to change the node’s name, not its parameters
|
||||
-- or metadata.
|
||||
--
|
||||
-- The swap will necessitate a light update unless update_light equals false.
|
||||
function mesecon.swap_node_force(pos, name, update_light)
|
||||
function mesecon.swap_node_force(pos, name)
|
||||
if vm_cache then
|
||||
return mesecon.vm_swap_node(pos, name, update_light)
|
||||
return mesecon.vm_swap_node(pos, name)
|
||||
else
|
||||
-- This serves to both ensure the mapblock is loaded and also hand us
|
||||
-- the old node table so we can preserve param2.
|
||||
|
||||
1
mesecons_alias/depends.txt
Normal file
1
mesecons_alias/depends.txt
Normal file
@ -0,0 +1 @@
|
||||
mesecons
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_alias
|
||||
depends = mesecons
|
||||
1
mesecons_blinkyplant/depends.txt
Normal file
1
mesecons_blinkyplant/depends.txt
Normal file
@ -0,0 +1 @@
|
||||
mesecons
|
||||
@ -26,19 +26,13 @@ mesecon.register_node("mesecons_blinkyplant:blinky_plant", {
|
||||
paramtype = "light",
|
||||
is_ground_content = false,
|
||||
walkable = false,
|
||||
sounds = mesecon.node_sound.leaves,
|
||||
sounds = default.node_sound_leaves_defaults(),
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
fixed = {-0.3, -0.5, -0.3, 0.3, -0.5+0.7, 0.3},
|
||||
},
|
||||
on_timer = on_timer,
|
||||
on_rightclick = function(pos, _, clicker)
|
||||
if minetest.is_protected(pos, clicker and clicker:get_player_name() or "") then
|
||||
return
|
||||
end
|
||||
|
||||
toggle_timer(pos)
|
||||
end,
|
||||
on_rightclick = toggle_timer,
|
||||
on_construct = toggle_timer
|
||||
},{
|
||||
tiles = {"jeija_blinky_plant_off.png"},
|
||||
@ -48,4 +42,11 @@ mesecon.register_node("mesecons_blinkyplant:blinky_plant", {
|
||||
tiles = {"jeija_blinky_plant_on.png"},
|
||||
groups = {dig_immediate=3, not_in_creative_inventory=1},
|
||||
mesecons = {receptor = { state = mesecon.state.on }}
|
||||
})
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_blinkyplant:blinky_plant_off 1",
|
||||
recipe = { {"","group:mesecon_conductor_craftable",""},
|
||||
{"","group:mesecon_conductor_craftable",""},
|
||||
{"group:sapling","group:sapling","group:sapling"}}
|
||||
})
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_blinkyplant
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
2
mesecons_button/depends.txt
Normal file
2
mesecons_button/depends.txt
Normal file
@ -0,0 +1,2 @@
|
||||
mesecons
|
||||
mesecons_receiver
|
||||
@ -8,24 +8,21 @@ mesecon.button_turnoff = function (pos)
|
||||
return
|
||||
end
|
||||
minetest.swap_node(pos, {name = "mesecons_button:button_off", param2 = node.param2})
|
||||
minetest.sound_play("mesecons_button_pop", { pos = pos }, true)
|
||||
minetest.sound_play("mesecons_button_pop", {pos = pos})
|
||||
local rules = mesecon.rules.buttonlike_get(node)
|
||||
mesecon.receptor_off(pos, rules)
|
||||
end
|
||||
|
||||
local use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "opaque" or nil
|
||||
|
||||
minetest.register_node("mesecons_button:button_off", {
|
||||
drawtype = "nodebox",
|
||||
tiles = {
|
||||
"jeija_wall_button_sides.png",
|
||||
"jeija_wall_button_sides.png",
|
||||
"jeija_wall_button_sides.png",
|
||||
"jeija_wall_button_sides.png",
|
||||
"jeija_wall_button_sides.png",
|
||||
"jeija_wall_button_off.png"
|
||||
"jeija_wall_button_sides.png",
|
||||
"jeija_wall_button_sides.png",
|
||||
"jeija_wall_button_sides.png",
|
||||
"jeija_wall_button_sides.png",
|
||||
"jeija_wall_button_sides.png",
|
||||
"jeija_wall_button_off.png"
|
||||
},
|
||||
use_texture_alpha = use_texture_alpha,
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
is_ground_content = false,
|
||||
@ -49,10 +46,10 @@ minetest.register_node("mesecons_button:button_off", {
|
||||
on_rightclick = function (pos, node)
|
||||
minetest.swap_node(pos, {name = "mesecons_button:button_on", param2=node.param2})
|
||||
mesecon.receptor_on(pos, mesecon.rules.buttonlike_get(node))
|
||||
minetest.sound_play("mesecons_button_push", { pos = pos }, true)
|
||||
minetest.sound_play("mesecons_button_push", {pos=pos})
|
||||
minetest.get_node_timer(pos):start(1)
|
||||
end,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {receptor = {
|
||||
state = mesecon.state.off,
|
||||
rules = mesecon.rules.buttonlike_get
|
||||
@ -69,8 +66,7 @@ minetest.register_node("mesecons_button:button_on", {
|
||||
"jeija_wall_button_sides.png",
|
||||
"jeija_wall_button_sides.png",
|
||||
"jeija_wall_button_on.png"
|
||||
},
|
||||
use_texture_alpha = use_texture_alpha,
|
||||
},
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
is_ground_content = false,
|
||||
@ -93,7 +89,7 @@ minetest.register_node("mesecons_button:button_on", {
|
||||
groups = {dig_immediate=2, not_in_creative_inventory=1, mesecon_needs_receiver = 1},
|
||||
drop = 'mesecons_button:button_off',
|
||||
description = "Button",
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {receptor = {
|
||||
state = mesecon.state.on,
|
||||
rules = mesecon.rules.buttonlike_get
|
||||
@ -101,3 +97,10 @@ minetest.register_node("mesecons_button:button_on", {
|
||||
on_timer = mesecon.button_turnoff,
|
||||
on_blast = mesecon.on_blastnode,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_button:button_off 2",
|
||||
recipe = {
|
||||
{"group:mesecon_conductor_craftable","default:stone"},
|
||||
}
|
||||
})
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_button
|
||||
depends = mesecons, mesecons_gamecompat, mesecons_receiver
|
||||
1
mesecons_commandblock/depends.txt
Normal file
1
mesecons_commandblock/depends.txt
Normal file
@ -0,0 +1 @@
|
||||
mesecons
|
||||
@ -10,7 +10,6 @@ minetest.register_chatcommand("say", {
|
||||
minetest.register_chatcommand("tell", {
|
||||
params = "<name> <text>",
|
||||
description = "Say <text> to <name> privately",
|
||||
privs = {shout=true},
|
||||
func = function(name, param)
|
||||
local found, _, target, message = param:find("^([^%s]+)%s+(.*)$")
|
||||
if found == nil then
|
||||
@ -79,7 +78,7 @@ local function after_place(pos, placer)
|
||||
end
|
||||
end
|
||||
|
||||
local function receive_fields(pos, _, fields, sender)
|
||||
local function receive_fields(pos, formname, fields, sender)
|
||||
if not fields.submit then
|
||||
return
|
||||
end
|
||||
@ -111,7 +110,7 @@ local function resolve_commands(commands, pos)
|
||||
local nearest, farthest = nil, nil
|
||||
local min_distance, max_distance = math.huge, -1
|
||||
for index, player in pairs(players) do
|
||||
local distance = vector.distance(pos, player:get_pos())
|
||||
local distance = vector.distance(pos, player:getpos())
|
||||
if distance < min_distance then
|
||||
min_distance = distance
|
||||
nearest = player:get_player_name()
|
||||
@ -175,8 +174,7 @@ end
|
||||
local function can_dig(pos, player)
|
||||
local meta = minetest.get_meta(pos)
|
||||
local owner = meta:get_string("owner")
|
||||
return owner == "" or owner == player:get_player_name() or
|
||||
minetest.check_player_privs(player, "protection_bypass")
|
||||
return owner == "" or owner == player:get_player_name()
|
||||
end
|
||||
|
||||
minetest.register_node("mesecons_commandblock:commandblock_off", {
|
||||
@ -189,7 +187,7 @@ minetest.register_node("mesecons_commandblock:commandblock_off", {
|
||||
after_place_node = after_place,
|
||||
on_receive_fields = receive_fields,
|
||||
can_dig = can_dig,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {effector = {
|
||||
action_on = commandblock_action_on
|
||||
}},
|
||||
@ -206,7 +204,7 @@ minetest.register_node("mesecons_commandblock:commandblock_on", {
|
||||
after_place_node = after_place,
|
||||
on_receive_fields = receive_fields,
|
||||
can_dig = can_dig,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {effector = {
|
||||
action_off = commandblock_action_off
|
||||
}},
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_commandblock
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
1
mesecons_delayer/depends.txt
Normal file
1
mesecons_delayer/depends.txt
Normal file
@ -0,0 +1 @@
|
||||
mesecons
|
||||
@ -1,7 +1,19 @@
|
||||
-- Function that get the input/output rules of the delayer
|
||||
local delayer_get_output_rules = mesecon.horiz_rules_getter({{x = 1, y = 0, z = 0}})
|
||||
local delayer_get_output_rules = function(node)
|
||||
local rules = {{x = 0, y = 0, z = 1}}
|
||||
for i = 0, node.param2 do
|
||||
rules = mesecon.rotate_rules_left(rules)
|
||||
end
|
||||
return rules
|
||||
end
|
||||
|
||||
local delayer_get_input_rules = mesecon.horiz_rules_getter({{x = -1, y = 0, z = 0}})
|
||||
local delayer_get_input_rules = function(node)
|
||||
local rules = {{x = 0, y = 0, z = -1}}
|
||||
for i = 0, node.param2 do
|
||||
rules = mesecon.rotate_rules_left(rules)
|
||||
end
|
||||
return rules
|
||||
end
|
||||
|
||||
-- Functions that are called after the delay time
|
||||
|
||||
@ -21,9 +33,19 @@ end
|
||||
|
||||
-- Register the 2 (states) x 4 (delay times) delayers
|
||||
|
||||
local delaytime = { 0.1, 0.3, 0.5, 1.0 }
|
||||
|
||||
for i = 1, 4 do
|
||||
local groups = {}
|
||||
if i == 1 then
|
||||
groups = {bendy=2,snappy=1,dig_immediate=2}
|
||||
else
|
||||
groups = {bendy=2,snappy=1,dig_immediate=2, not_in_creative_inventory=1}
|
||||
end
|
||||
|
||||
local delaytime
|
||||
if i == 1 then delaytime = 0.1
|
||||
elseif i == 2 then delaytime = 0.3
|
||||
elseif i == 3 then delaytime = 0.5
|
||||
elseif i == 4 then delaytime = 1.0 end
|
||||
|
||||
local boxes = {
|
||||
{ -6/16, -8/16, -6/16, 6/16, -7/16, 6/16 }, -- the main slab
|
||||
@ -39,10 +61,19 @@ local boxes = {
|
||||
{ 6/16, -8/16, -1/16, 8/16, -7/16, 1/16 }
|
||||
}
|
||||
|
||||
-- Delayer definition defaults
|
||||
local def = {
|
||||
minetest.register_node("mesecons_delayer:delayer_off_"..tostring(i), {
|
||||
description = "Delayer",
|
||||
drawtype = "nodebox",
|
||||
use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "opaque" or nil,
|
||||
tiles = {
|
||||
"mesecons_delayer_off_"..tostring(i)..".png",
|
||||
"mesecons_delayer_bottom.png",
|
||||
"mesecons_delayer_ends_off.png",
|
||||
"mesecons_delayer_ends_off.png",
|
||||
"mesecons_delayer_sides_off.png",
|
||||
"mesecons_delayer_sides_off.png"
|
||||
},
|
||||
inventory_image = "mesecons_delayer_off_1.png",
|
||||
wield_image = "mesecons_delayer_off_1.png",
|
||||
walkable = true,
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
@ -52,46 +83,26 @@ local def = {
|
||||
type = "fixed",
|
||||
fixed = boxes
|
||||
},
|
||||
groups = groups,
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
sunlight_propagates = true,
|
||||
is_ground_content = false,
|
||||
delayer_time = delaytime[i],
|
||||
sounds = mesecon.node_sound.stone,
|
||||
on_blast = mesecon.on_blastnode,
|
||||
drop = "mesecons_delayer:delayer_off_1",
|
||||
}
|
||||
|
||||
-- Deactivated delayer definition defaults
|
||||
local off_groups = {bendy=2,snappy=1,dig_immediate=2}
|
||||
if i > 1 then
|
||||
off_groups.not_in_creative_inventory = 1
|
||||
end
|
||||
|
||||
local off_state = {
|
||||
description = "Delayer",
|
||||
tiles = {
|
||||
"mesecons_delayer_off_"..tostring(i)..".png",
|
||||
"mesecons_delayer_bottom.png",
|
||||
"mesecons_delayer_ends_off.png",
|
||||
"mesecons_delayer_ends_off.png",
|
||||
"mesecons_delayer_sides_off.png",
|
||||
"mesecons_delayer_sides_off.png"
|
||||
},
|
||||
inventory_image = "mesecons_delayer_off_1.png",
|
||||
wield_image = "mesecons_delayer_off_1.png",
|
||||
groups = off_groups,
|
||||
on_punch = function(pos, node, puncher)
|
||||
if minetest.is_protected(pos, puncher and puncher:get_player_name() or "") then
|
||||
return
|
||||
drop = 'mesecons_delayer:delayer_off_1',
|
||||
on_punch = function (pos, node)
|
||||
if node.name=="mesecons_delayer:delayer_off_1" then
|
||||
minetest.swap_node(pos, {name = "mesecons_delayer:delayer_off_2", param2=node.param2})
|
||||
elseif node.name=="mesecons_delayer:delayer_off_2" then
|
||||
minetest.swap_node(pos, {name = "mesecons_delayer:delayer_off_3", param2=node.param2})
|
||||
elseif node.name=="mesecons_delayer:delayer_off_3" then
|
||||
minetest.swap_node(pos, {name = "mesecons_delayer:delayer_off_4", param2=node.param2})
|
||||
elseif node.name=="mesecons_delayer:delayer_off_4" then
|
||||
minetest.swap_node(pos, {name = "mesecons_delayer:delayer_off_1", param2=node.param2})
|
||||
end
|
||||
|
||||
minetest.swap_node(pos, {
|
||||
name = "mesecons_delayer:delayer_off_"..tostring(i % 4 + 1),
|
||||
param2 = node.param2
|
||||
})
|
||||
end,
|
||||
delayer_time = delaytime,
|
||||
delayer_onstate = "mesecons_delayer:delayer_on_"..tostring(i),
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {
|
||||
receptor =
|
||||
{
|
||||
@ -104,15 +115,13 @@ local off_state = {
|
||||
action_on = delayer_activate
|
||||
}
|
||||
},
|
||||
}
|
||||
for k, v in pairs(def) do
|
||||
off_state[k] = off_state[k] or v
|
||||
end
|
||||
minetest.register_node("mesecons_delayer:delayer_off_"..tostring(i), off_state)
|
||||
on_blast = mesecon.on_blastnode,
|
||||
})
|
||||
|
||||
-- Activated delayer definition defaults
|
||||
local on_state = {
|
||||
|
||||
minetest.register_node("mesecons_delayer:delayer_on_"..tostring(i), {
|
||||
description = "You hacker you",
|
||||
drawtype = "nodebox",
|
||||
tiles = {
|
||||
"mesecons_delayer_on_"..tostring(i)..".png",
|
||||
"mesecons_delayer_bottom.png",
|
||||
@ -120,19 +129,36 @@ local on_state = {
|
||||
"mesecons_delayer_ends_on.png",
|
||||
"mesecons_delayer_sides_on.png",
|
||||
"mesecons_delayer_sides_on.png"
|
||||
},
|
||||
walkable = true,
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
fixed = { -8/16, -8/16, -8/16, 8/16, -6/16, 8/16 },
|
||||
},
|
||||
node_box = {
|
||||
type = "fixed",
|
||||
fixed = boxes
|
||||
},
|
||||
groups = {bendy = 2, snappy = 1, dig_immediate = 2, not_in_creative_inventory = 1},
|
||||
on_punch = function(pos, node, puncher)
|
||||
if minetest.is_protected(pos, puncher and puncher:get_player_name() or "") then
|
||||
return
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
sunlight_propagates = true,
|
||||
is_ground_content = false,
|
||||
drop = 'mesecons_delayer:delayer_off_1',
|
||||
on_punch = function (pos, node)
|
||||
if node.name=="mesecons_delayer:delayer_on_1" then
|
||||
minetest.swap_node(pos, {name = "mesecons_delayer:delayer_on_2", param2=node.param2})
|
||||
elseif node.name=="mesecons_delayer:delayer_on_2" then
|
||||
minetest.swap_node(pos, {name = "mesecons_delayer:delayer_on_3", param2=node.param2})
|
||||
elseif node.name=="mesecons_delayer:delayer_on_3" then
|
||||
minetest.swap_node(pos, {name = "mesecons_delayer:delayer_on_4", param2=node.param2})
|
||||
elseif node.name=="mesecons_delayer:delayer_on_4" then
|
||||
minetest.swap_node(pos, {name = "mesecons_delayer:delayer_on_1", param2=node.param2})
|
||||
end
|
||||
|
||||
minetest.swap_node(pos, {
|
||||
name = "mesecons_delayer:delayer_on_"..tostring(i % 4 + 1),
|
||||
param2 = node.param2
|
||||
})
|
||||
end,
|
||||
delayer_time = delaytime,
|
||||
delayer_offstate = "mesecons_delayer:delayer_off_"..tostring(i),
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {
|
||||
receptor =
|
||||
{
|
||||
@ -145,10 +171,14 @@ local on_state = {
|
||||
action_off = delayer_deactivate
|
||||
}
|
||||
},
|
||||
}
|
||||
for k, v in pairs(def) do
|
||||
on_state[k] = on_state[k] or v
|
||||
on_blast = mesecon.on_blastnode,
|
||||
})
|
||||
end
|
||||
minetest.register_node("mesecons_delayer:delayer_on_"..tostring(i), on_state)
|
||||
|
||||
end
|
||||
minetest.register_craft({
|
||||
output = "mesecons_delayer:delayer_off_1",
|
||||
recipe = {
|
||||
{"mesecons_torch:mesecon_torch_on", "group:mesecon_conductor_craftable", "mesecons_torch:mesecon_torch_on"},
|
||||
{"default:cobble","default:cobble", "default:cobble"},
|
||||
}
|
||||
})
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_delayer
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
2
mesecons_detector/depends.txt
Normal file
2
mesecons_detector/depends.txt
Normal file
@ -0,0 +1,2 @@
|
||||
mesecons
|
||||
mesecons_materials
|
||||
@ -1,5 +1,3 @@
|
||||
local side_texture = "mesecons_detector_side.png"
|
||||
|
||||
local GET_COMMAND = "GET"
|
||||
|
||||
-- Object detector
|
||||
@ -14,7 +12,7 @@ local function object_detector_make_formspec(pos)
|
||||
"button_exit[7,0.75;2,3;;Save]")
|
||||
end
|
||||
|
||||
local function object_detector_on_receive_fields(pos, _, fields, sender)
|
||||
local function object_detector_on_receive_fields(pos, formname, fields, sender)
|
||||
if not fields.scanname or not fields.digiline_channel then return end
|
||||
|
||||
if minetest.is_protected(pos, sender:get_player_name()) then return end
|
||||
@ -55,7 +53,7 @@ end
|
||||
-- set player name when receiving a digiline signal on a specific channel
|
||||
local object_detector_digiline = {
|
||||
effector = {
|
||||
action = function(pos, _, channel, msg)
|
||||
action = function(pos, node, channel, msg)
|
||||
local meta = minetest.get_meta(pos)
|
||||
if channel == meta:get_string("digiline_channel") then
|
||||
meta:set_string("scanname", msg)
|
||||
@ -66,7 +64,7 @@ local object_detector_digiline = {
|
||||
}
|
||||
|
||||
minetest.register_node("mesecons_detector:object_detector_off", {
|
||||
tiles = {side_texture, side_texture, "jeija_object_detector_off.png", "jeija_object_detector_off.png", "jeija_object_detector_off.png", "jeija_object_detector_off.png"},
|
||||
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",
|
||||
is_ground_content = false,
|
||||
walkable = true,
|
||||
@ -78,13 +76,13 @@ minetest.register_node("mesecons_detector:object_detector_off", {
|
||||
}},
|
||||
on_construct = object_detector_make_formspec,
|
||||
on_receive_fields = object_detector_on_receive_fields,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
digiline = object_detector_digiline,
|
||||
on_blast = mesecon.on_blastnode,
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_detector:object_detector_on", {
|
||||
tiles = {side_texture, side_texture, "jeija_object_detector_on.png", "jeija_object_detector_on.png", "jeija_object_detector_on.png", "jeija_object_detector_on.png"},
|
||||
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",
|
||||
is_ground_content = false,
|
||||
walkable = true,
|
||||
@ -96,11 +94,29 @@ minetest.register_node("mesecons_detector:object_detector_on", {
|
||||
}},
|
||||
on_construct = object_detector_make_formspec,
|
||||
on_receive_fields = object_detector_on_receive_fields,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
digiline = object_detector_digiline,
|
||||
on_blast = mesecon.on_blastnode,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = 'mesecons_detector:object_detector_off',
|
||||
recipe = {
|
||||
{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
|
||||
{"default:steel_ingot", "mesecons_luacontroller:luacontroller0000", "default:steel_ingot"},
|
||||
{"default:steel_ingot", "group:mesecon_conductor_craftable", "default:steel_ingot"},
|
||||
}
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = 'mesecons_detector:object_detector_off',
|
||||
recipe = {
|
||||
{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
|
||||
{"default:steel_ingot", "mesecons_microcontroller:microcontroller0000", "default:steel_ingot"},
|
||||
{"default:steel_ingot", "group:mesecon_conductor_craftable", "default:steel_ingot"},
|
||||
}
|
||||
})
|
||||
|
||||
minetest.register_abm({
|
||||
nodenames = {"mesecons_detector:object_detector_off"},
|
||||
interval = 1,
|
||||
@ -140,7 +156,7 @@ local function node_detector_make_formspec(pos)
|
||||
"button_exit[7,0.75;2,3;;Save]")
|
||||
end
|
||||
|
||||
local function node_detector_on_receive_fields(pos, _, fields, sender)
|
||||
local function node_detector_on_receive_fields(pos, fieldname, fields, sender)
|
||||
if not fields.scanname or not fields.digiline_channel then return end
|
||||
|
||||
if minetest.is_protected(pos, sender:get_player_name()) then return end
|
||||
@ -222,8 +238,25 @@ local node_detector_digiline = {
|
||||
receptor = {}
|
||||
}
|
||||
|
||||
local function after_place_node_detector(pos, placer)
|
||||
local placer_pos = placer:getpos()
|
||||
if not placer_pos then
|
||||
return
|
||||
end
|
||||
|
||||
--correct for the player's height
|
||||
if placer:is_player() then
|
||||
placer_pos.y = placer_pos.y + 1.625
|
||||
end
|
||||
|
||||
--correct for 6d facedir
|
||||
local node = minetest.get_node(pos)
|
||||
node.param2 = minetest.dir_to_facedir(vector.subtract(pos, placer_pos), true)
|
||||
minetest.set_node(pos, node)
|
||||
end
|
||||
|
||||
minetest.register_node("mesecons_detector:node_detector_off", {
|
||||
tiles = {side_texture, side_texture, side_texture, side_texture, side_texture, "jeija_node_detector_off.png"},
|
||||
tiles = {"default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "jeija_node_detector_off.png"},
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
is_ground_content = false,
|
||||
@ -235,13 +268,13 @@ minetest.register_node("mesecons_detector:node_detector_off", {
|
||||
}},
|
||||
on_construct = node_detector_make_formspec,
|
||||
on_receive_fields = node_detector_on_receive_fields,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
digiline = node_detector_digiline,
|
||||
on_blast = mesecon.on_blastnode,
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_detector:node_detector_on", {
|
||||
tiles = {side_texture, side_texture, side_texture, side_texture, side_texture, "jeija_node_detector_on.png"},
|
||||
tiles = {"default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "jeija_node_detector_on.png"},
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
is_ground_content = false,
|
||||
@ -253,10 +286,29 @@ minetest.register_node("mesecons_detector:node_detector_on", {
|
||||
}},
|
||||
on_construct = node_detector_make_formspec,
|
||||
on_receive_fields = node_detector_on_receive_fields,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
digiline = node_detector_digiline,
|
||||
on_blast = mesecon.on_blastnode,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = 'mesecons_detector:node_detector_off',
|
||||
recipe = {
|
||||
{"default:steel_ingot", "group:mesecon_conductor_craftable", "default:steel_ingot"},
|
||||
{"default:steel_ingot", "mesecons_luacontroller:luacontroller0000", "default:steel_ingot"},
|
||||
{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
|
||||
}
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = 'mesecons_detector:node_detector_off',
|
||||
recipe = {
|
||||
{"default:steel_ingot", "group:mesecon_conductor_craftable", "default:steel_ingot"},
|
||||
{"default:steel_ingot", "mesecons_microcontroller:microcontroller0000", "default:steel_ingot"},
|
||||
{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
|
||||
}
|
||||
})
|
||||
|
||||
minetest.register_abm({
|
||||
nodenames = {"mesecons_detector:node_detector_off"},
|
||||
interval = 1,
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_detector
|
||||
depends = mesecons, mesecons_gamecompat, mesecons_materials
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 350 B |
2
mesecons_doors/depends.txt
Normal file
2
mesecons_doors/depends.txt
Normal file
@ -0,0 +1,2 @@
|
||||
mesecons
|
||||
doors
|
||||
129
mesecons_doors/init.lua
Normal file
129
mesecons_doors/init.lua
Normal file
@ -0,0 +1,129 @@
|
||||
-- Modified, from minetest_game/mods/doors/init.lua
|
||||
local function on_rightclick(pos, dir, check_name, replace, replace_dir, params)
|
||||
pos.y = pos.y + dir
|
||||
if not minetest.get_node(pos).name == check_name then
|
||||
return
|
||||
end
|
||||
local p2 = minetest.get_node(pos).param2
|
||||
p2 = params[p2 + 1]
|
||||
|
||||
minetest.swap_node(pos, {name = replace_dir, param2 = p2})
|
||||
|
||||
pos.y = pos.y - dir
|
||||
minetest.swap_node(pos, {name = replace, param2 = p2})
|
||||
|
||||
if (minetest.get_meta(pos):get_int("right") ~= 0) == (params[1] ~= 3) then
|
||||
minetest.sound_play("doors_door_close", {pos = pos, gain = 0.3, max_hear_distance = 10})
|
||||
else
|
||||
minetest.sound_play("doors_door_open", {pos = pos, gain = 0.3, max_hear_distance = 10})
|
||||
end
|
||||
end
|
||||
|
||||
local function meseconify_door(name)
|
||||
if minetest.registered_items[name .. "_b_1"] then
|
||||
-- old style double-node doors
|
||||
local function toggle_state1 (pos, node)
|
||||
on_rightclick(pos, 1, name.."_t_1", name.."_b_2", name.."_t_2", {1,2,3,0})
|
||||
end
|
||||
|
||||
local function toggle_state2 (pos, node)
|
||||
on_rightclick(pos, 1, name.."_t_2", name.."_b_1", name.."_t_1", {3,0,1,2})
|
||||
end
|
||||
|
||||
minetest.override_item(name.."_b_1", {
|
||||
mesecons = {effector = {
|
||||
action_on = toggle_state1,
|
||||
action_off = toggle_state1,
|
||||
rules = mesecon.rules.pplate
|
||||
}}
|
||||
})
|
||||
|
||||
minetest.override_item(name.."_b_2", {
|
||||
mesecons = {effector = {
|
||||
action_on = toggle_state2,
|
||||
action_off = toggle_state2,
|
||||
rules = mesecon.rules.pplate
|
||||
}}
|
||||
})
|
||||
elseif minetest.registered_items[name .. "_a"] then
|
||||
-- new style mesh node based doors
|
||||
local override = {
|
||||
mesecons = {effector = {
|
||||
action_on = function(pos, node)
|
||||
local door = doors.get(pos)
|
||||
if door then
|
||||
door:open()
|
||||
end
|
||||
end,
|
||||
action_off = function(pos, node)
|
||||
local door = doors.get(pos)
|
||||
if door then
|
||||
door:close()
|
||||
end
|
||||
end,
|
||||
rules = mesecon.rules.pplate
|
||||
}}
|
||||
}
|
||||
minetest.override_item(name .. "_a", override)
|
||||
minetest.override_item(name .. "_b", override)
|
||||
end
|
||||
end
|
||||
|
||||
meseconify_door("doors:door_wood")
|
||||
meseconify_door("doors:door_steel")
|
||||
meseconify_door("doors:door_glass")
|
||||
meseconify_door("doors:door_obsidian_glass")
|
||||
|
||||
-- Trapdoor
|
||||
local function trapdoor_switch(pos, node)
|
||||
local state = minetest.get_meta(pos):get_int("state")
|
||||
|
||||
if state == 1 then
|
||||
minetest.sound_play("doors_door_close", {pos = pos, gain = 0.3, max_hear_distance = 10})
|
||||
minetest.set_node(pos, {name="doors:trapdoor", param2 = node.param2})
|
||||
else
|
||||
minetest.sound_play("doors_door_open", {pos = pos, gain = 0.3, max_hear_distance = 10})
|
||||
minetest.set_node(pos, {name="doors:trapdoor_open", param2 = node.param2})
|
||||
end
|
||||
|
||||
minetest.get_meta(pos):set_int("state", state == 1 and 0 or 1)
|
||||
end
|
||||
|
||||
if doors and doors.get then
|
||||
local override = {
|
||||
mesecons = {effector = {
|
||||
action_on = function(pos, node)
|
||||
local door = doors.get(pos)
|
||||
if door then
|
||||
door:open()
|
||||
end
|
||||
end,
|
||||
action_off = function(pos, node)
|
||||
local door = doors.get(pos)
|
||||
if door then
|
||||
door:close()
|
||||
end
|
||||
end,
|
||||
}},
|
||||
}
|
||||
minetest.override_item("doors:trapdoor", override)
|
||||
minetest.override_item("doors:trapdoor_open", override)
|
||||
minetest.override_item("doors:trapdoor_steel", override)
|
||||
minetest.override_item("doors:trapdoor_steel_open", override)
|
||||
else
|
||||
if minetest.registered_nodes["doors:trapdoor"] then
|
||||
minetest.override_item("doors:trapdoor", {
|
||||
mesecons = {effector = {
|
||||
action_on = trapdoor_switch,
|
||||
action_off = trapdoor_switch
|
||||
}},
|
||||
})
|
||||
|
||||
minetest.override_item("doors:trapdoor_open", {
|
||||
mesecons = {effector = {
|
||||
action_on = trapdoor_switch,
|
||||
action_off = trapdoor_switch
|
||||
}},
|
||||
})
|
||||
end
|
||||
end
|
||||
@ -1,19 +1,38 @@
|
||||
local screwdriver_exists = minetest.global_exists("screwdriver")
|
||||
|
||||
local corner_nodebox = {
|
||||
type = "fixed",
|
||||
-- ±0.001 is to prevent z-fighting
|
||||
fixed = {{ -16/32-0.001, -17/32, -3/32, 0, -13/32, 3/32 },
|
||||
{ -3/32, -17/32, -16/32+0.001, 3/32, -13/32, 3/32}}
|
||||
}
|
||||
|
||||
local corner_selectionbox = {
|
||||
type = "fixed",
|
||||
fixed = { -16/32, -16/32, -16/32, 5/32, -12/32, 5/32 },
|
||||
}
|
||||
|
||||
local corner_get_rules = mesecon.horiz_rules_getter({
|
||||
{x = 0, y = 0, z = -1},
|
||||
{x = -1, y = 0, z = 0},
|
||||
})
|
||||
local corner_get_rules = function (node)
|
||||
local rules =
|
||||
{{x = 1, y = 0, z = 0},
|
||||
{x = 0, y = 0, z = -1}}
|
||||
|
||||
for i = 0, node.param2 do
|
||||
rules = mesecon.rotate_rules_left(rules)
|
||||
end
|
||||
|
||||
return rules
|
||||
end
|
||||
|
||||
minetest.register_node("mesecons_extrawires:corner_on", {
|
||||
drawtype = "mesh",
|
||||
mesh = "mesecons_extrawires_corner.obj",
|
||||
drawtype = "nodebox",
|
||||
tiles = {
|
||||
{ name = "jeija_insulated_wire_sides_on.png", backface_culling = true },
|
||||
{ name = "jeija_insulated_wire_ends_on.png", backface_culling = true },
|
||||
"jeija_insulated_wire_curved_tb_on.png",
|
||||
"jeija_insulated_wire_curved_tb_on.png^[transformR270",
|
||||
"jeija_insulated_wire_sides_on.png",
|
||||
"jeija_insulated_wire_ends_on.png",
|
||||
"jeija_insulated_wire_sides_on.png",
|
||||
"jeija_insulated_wire_ends_on.png"
|
||||
},
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
@ -21,9 +40,10 @@ minetest.register_node("mesecons_extrawires:corner_on", {
|
||||
walkable = false,
|
||||
sunlight_propagates = true,
|
||||
selection_box = corner_selectionbox,
|
||||
node_box = corner_nodebox,
|
||||
groups = {dig_immediate = 3, not_in_creative_inventory = 1},
|
||||
drop = "mesecons_extrawires:corner_off",
|
||||
sounds = mesecon.node_sound.default,
|
||||
sounds = default.node_sound_defaults(),
|
||||
mesecons = {conductor =
|
||||
{
|
||||
state = mesecon.state.on,
|
||||
@ -31,16 +51,19 @@ minetest.register_node("mesecons_extrawires:corner_on", {
|
||||
offstate = "mesecons_extrawires:corner_off"
|
||||
}},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
on_rotate = mesecon.on_rotate_horiz,
|
||||
on_rotate = screwdriver_exists and screwdriver.rotate_simple,
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_extrawires:corner_off", {
|
||||
drawtype = "mesh",
|
||||
drawtype = "nodebox",
|
||||
description = "Insulated Mesecon Corner",
|
||||
mesh = "mesecons_extrawires_corner.obj",
|
||||
tiles = {
|
||||
{ name = "jeija_insulated_wire_sides_off.png", backface_culling = true },
|
||||
{ name = "jeija_insulated_wire_ends_off.png", backface_culling = true },
|
||||
"jeija_insulated_wire_curved_tb_off.png",
|
||||
"jeija_insulated_wire_curved_tb_off.png^[transformR270",
|
||||
"jeija_insulated_wire_sides_off.png",
|
||||
"jeija_insulated_wire_ends_off.png",
|
||||
"jeija_insulated_wire_sides_off.png",
|
||||
"jeija_insulated_wire_ends_off.png"
|
||||
},
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
@ -48,8 +71,9 @@ minetest.register_node("mesecons_extrawires:corner_off", {
|
||||
walkable = false,
|
||||
sunlight_propagates = true,
|
||||
selection_box = corner_selectionbox,
|
||||
node_box = corner_nodebox,
|
||||
groups = {dig_immediate = 3},
|
||||
sounds = mesecon.node_sound.default,
|
||||
sounds = default.node_sound_defaults(),
|
||||
mesecons = {conductor =
|
||||
{
|
||||
state = mesecon.state.off,
|
||||
@ -57,5 +81,14 @@ minetest.register_node("mesecons_extrawires:corner_off", {
|
||||
onstate = "mesecons_extrawires:corner_on"
|
||||
}},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
on_rotate = mesecon.on_rotate_horiz,
|
||||
on_rotate = screwdriver_exists and screwdriver.rotate_simple,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_extrawires:corner_off 3",
|
||||
recipe = {
|
||||
{"", "", ""},
|
||||
{"mesecons_insulated:insulated_off", "mesecons_insulated:insulated_off", ""},
|
||||
{"", "mesecons_insulated:insulated_off", ""},
|
||||
}
|
||||
})
|
||||
|
||||
@ -1,13 +1,15 @@
|
||||
local crossover_rules = {
|
||||
{--first wire
|
||||
{x=-1,y=0,z=0},
|
||||
{x=1,y=0,z=0},
|
||||
},
|
||||
{--second wire
|
||||
{x=0,y=0,z=-1},
|
||||
{x=0,y=0,z=1},
|
||||
},
|
||||
}
|
||||
local function crossover_get_rules(node)
|
||||
return {
|
||||
{--first wire
|
||||
{x=-1,y=0,z=0},
|
||||
{x=1,y=0,z=0},
|
||||
},
|
||||
{--second wire
|
||||
{x=0,y=0,z=-1},
|
||||
{x=0,y=0,z=1},
|
||||
},
|
||||
}
|
||||
end
|
||||
|
||||
local crossover_states = {
|
||||
"mesecons_extrawires:crossover_off",
|
||||
@ -32,11 +34,11 @@ minetest.register_node("mesecons_extrawires:crossover_off", {
|
||||
stack_max = 99,
|
||||
selection_box = {type="fixed", fixed={-16/32, -16/32, -16/32, 16/32, -5/32, 16/32}},
|
||||
groups = {dig_immediate=3, mesecon=3},
|
||||
sounds = mesecon.node_sound.default,
|
||||
sounds = default.node_sound_defaults(),
|
||||
mesecons = {
|
||||
conductor = {
|
||||
states = crossover_states,
|
||||
rules = crossover_rules,
|
||||
rules = crossover_get_rules(),
|
||||
}
|
||||
},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
@ -59,11 +61,11 @@ minetest.register_node("mesecons_extrawires:crossover_01", {
|
||||
stack_max = 99,
|
||||
selection_box = {type="fixed", fixed={-16/32, -16/32, -16/32, 16/32, -5/32, 16/32}},
|
||||
groups = {dig_immediate=3, mesecon=3, not_in_creative_inventory=1},
|
||||
sounds = mesecon.node_sound.default,
|
||||
sounds = default.node_sound_defaults(),
|
||||
mesecons = {
|
||||
conductor = {
|
||||
states = crossover_states,
|
||||
rules = crossover_rules,
|
||||
rules = crossover_get_rules(),
|
||||
}
|
||||
},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
@ -86,11 +88,11 @@ minetest.register_node("mesecons_extrawires:crossover_10", {
|
||||
stack_max = 99,
|
||||
selection_box = {type="fixed", fixed={-16/32, -16/32, -16/32, 16/32, -5/32, 16/32}},
|
||||
groups = {dig_immediate=3, mesecon=3, not_in_creative_inventory=1},
|
||||
sounds = mesecon.node_sound.default,
|
||||
sounds = default.node_sound_defaults(),
|
||||
mesecons = {
|
||||
conductor = {
|
||||
states = crossover_states,
|
||||
rules = crossover_rules,
|
||||
rules = crossover_get_rules(),
|
||||
}
|
||||
},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
@ -113,12 +115,29 @@ minetest.register_node("mesecons_extrawires:crossover_on", {
|
||||
stack_max = 99,
|
||||
selection_box = {type="fixed", fixed={-16/32, -16/32, -16/32, 16/32, -5/32, 16/32}},
|
||||
groups = {dig_immediate=3, mesecon=3, not_in_creative_inventory=1},
|
||||
sounds = mesecon.node_sound.default,
|
||||
sounds = default.node_sound_defaults(),
|
||||
mesecons = {
|
||||
conductor = {
|
||||
states = crossover_states,
|
||||
rules = crossover_rules,
|
||||
rules = crossover_get_rules(),
|
||||
}
|
||||
},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
})
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = "mesecons_extrawires:crossover_off",
|
||||
recipe = {
|
||||
"mesecons_insulated:insulated_off",
|
||||
"mesecons_insulated:insulated_off",
|
||||
},
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = "mesecons_insulated:insulated_off 2",
|
||||
recipe = {
|
||||
"mesecons_extrawires:crossover_off",
|
||||
},
|
||||
})
|
||||
|
||||
3
mesecons_extrawires/depends.txt
Normal file
3
mesecons_extrawires/depends.txt
Normal file
@ -0,0 +1,3 @@
|
||||
default
|
||||
mesecons
|
||||
screwdriver?
|
||||
@ -1,59 +0,0 @@
|
||||
local doublecorner_selectionbox = {
|
||||
type = "fixed",
|
||||
fixed = { -8/16, -8/16, -8/16, 8/16, -6/16, 8/16 },
|
||||
}
|
||||
|
||||
local doublecorner_get_rules = mesecon.horiz_rules_getter({
|
||||
{
|
||||
{ x = 1, y = 0, z = 0 },
|
||||
{ x = 0, y = 0, z = 1 },
|
||||
},
|
||||
{
|
||||
{ x = -1, y = 0, z = 0 },
|
||||
{ x = 0, y = 0, z = -1 },
|
||||
},
|
||||
})
|
||||
|
||||
local doublecorner_states = {
|
||||
"mesecons_extrawires:doublecorner_00",
|
||||
"mesecons_extrawires:doublecorner_01",
|
||||
"mesecons_extrawires:doublecorner_10",
|
||||
"mesecons_extrawires:doublecorner_11",
|
||||
}
|
||||
local wire1_states = { "off", "off", "on", "on" }
|
||||
local wire2_states = { "off", "on", "off", "on" }
|
||||
|
||||
for k, state in ipairs(doublecorner_states) do
|
||||
local w1 = wire1_states[k]
|
||||
local w2 = wire2_states[k]
|
||||
local groups = { dig_immediate = 3 }
|
||||
if k ~= 1 then groups.not_in_creative_inventory = 1 end
|
||||
minetest.register_node(state, {
|
||||
drawtype = "mesh",
|
||||
mesh = "mesecons_extrawires_doublecorner.obj",
|
||||
description = "Insulated Mesecon Double Corner",
|
||||
tiles = {
|
||||
{ name = "jeija_insulated_wire_sides_" .. w1 .. ".png", backface_culling = true },
|
||||
{ name = "jeija_insulated_wire_ends_" .. w1 .. ".png", backface_culling = true },
|
||||
{ name = "jeija_insulated_wire_sides_" .. w2 .. ".png", backface_culling = true },
|
||||
{ name = "jeija_insulated_wire_ends_" .. w2 .. ".png", backface_culling = true },
|
||||
},
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
is_ground_content = false,
|
||||
walkable = false,
|
||||
sunlight_propagates = true,
|
||||
selection_box = doublecorner_selectionbox,
|
||||
groups = groups,
|
||||
drop = doublecorner_states[1],
|
||||
sounds = mesecon.node_sound.default,
|
||||
mesecons = {
|
||||
conductor = {
|
||||
states = doublecorner_states,
|
||||
rules = doublecorner_get_rules,
|
||||
},
|
||||
},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
on_rotate = mesecon.on_rotate_horiz,
|
||||
})
|
||||
end
|
||||
@ -1,6 +1,5 @@
|
||||
dofile(minetest.get_modpath("mesecons_extrawires").."/crossover.lua");
|
||||
dofile(minetest.get_modpath("mesecons_extrawires").."/tjunction.lua");
|
||||
dofile(minetest.get_modpath("mesecons_extrawires").."/corner.lua");
|
||||
dofile(minetest.get_modpath("mesecons_extrawires").."/doublecorner.lua");
|
||||
dofile(minetest.get_modpath("mesecons_extrawires").."/vertical.lua");
|
||||
dofile(minetest.get_modpath("mesecons_extrawires").."/mesewire.lua");
|
||||
|
||||
@ -1,20 +1,3 @@
|
||||
local mese_nodename = minetest.registered_aliases["mesecons_gamecompat:mese"]
|
||||
if mese_nodename then
|
||||
-- Convert placeholders.
|
||||
minetest.register_alias("mesecons_extrawires:mese", mese_nodename)
|
||||
else
|
||||
-- Register placeholder.
|
||||
mese_nodename = "mesecons_extrawires:mese"
|
||||
minetest.register_node("mesecons_extrawires:mese", {
|
||||
description = "Mese Wire",
|
||||
tiles = {"mesecons_wire_off.png"},
|
||||
paramtype = "light",
|
||||
light_source = 3,
|
||||
groups = {cracky = 1},
|
||||
sounds = mesecon.node_sound.stone,
|
||||
})
|
||||
end
|
||||
|
||||
local mesewire_rules =
|
||||
{
|
||||
{x = 1, y = 0, z = 0},
|
||||
@ -25,7 +8,7 @@ local mesewire_rules =
|
||||
{x = 0, y = 0, z =-1},
|
||||
}
|
||||
|
||||
minetest.override_item(mese_nodename, {
|
||||
minetest.override_item("default:mese", {
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.off,
|
||||
onstate = "mesecons_extrawires:mese_powered",
|
||||
@ -35,17 +18,15 @@ minetest.override_item(mese_nodename, {
|
||||
|
||||
-- Copy node definition of powered mese from normal mese
|
||||
-- and brighten texture tiles to indicate mese is powered
|
||||
local unpowered_def = minetest.registered_nodes[mese_nodename]
|
||||
local powered_def = mesecon.merge_tables(unpowered_def, {
|
||||
drop = mese_nodename,
|
||||
paramtype = "light",
|
||||
light_source = math.min(unpowered_def.light_source + 2, minetest.LIGHT_MAX),
|
||||
local powered_def = mesecon.mergetable(minetest.registered_nodes["default:mese"], {
|
||||
drop = "default:mese",
|
||||
light_source = 5,
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.on,
|
||||
offstate = mese_nodename,
|
||||
offstate = "default:mese",
|
||||
rules = mesewire_rules
|
||||
}},
|
||||
groups = mesecon.merge_tables(unpowered_def.groups or {}, {not_in_creative_inventory = 1}),
|
||||
groups = {cracky = 1, not_in_creative_inventory = 1},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
})
|
||||
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_extrawires
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
@ -1,125 +0,0 @@
|
||||
# Вершины
|
||||
# Провод 1
|
||||
# 1 (ниж. внутр.)
|
||||
v 0.093750 -0.531250 -0.501000
|
||||
v 0.093750 -0.531250 -0.331726
|
||||
v 0.331726 -0.531250 -0.093750
|
||||
v 0.501000 -0.531250 -0.093750
|
||||
# 5 (ниж. наруж.)
|
||||
v -0.093750 -0.531250 -0.501000
|
||||
v -0.093750 -0.531250 -0.254061
|
||||
v 0.254061 -0.531250 0.093750
|
||||
v 0.501000 -0.531250 0.093750
|
||||
# 9 (верх. внутр.)
|
||||
v 0.093750 -0.406250 -0.501000
|
||||
v 0.093750 -0.406250 -0.331726
|
||||
v 0.331726 -0.406250 -0.093750
|
||||
v 0.501000 -0.406250 -0.093750
|
||||
# 13 (верх. наруж.)
|
||||
v -0.093750 -0.406250 -0.501000
|
||||
v -0.093750 -0.406250 -0.254061
|
||||
v 0.254061 -0.406250 0.093750
|
||||
v 0.501000 -0.406250 0.093750
|
||||
# Текстурные координаты
|
||||
# 1 (ниж.)
|
||||
vt 0.000000 0.406250
|
||||
vt 0.168274 0.406250
|
||||
vt 0.331726 0.406250
|
||||
vt 0.668274 0.406250
|
||||
vt 0.831726 0.406250
|
||||
vt 1.000000 0.406250
|
||||
vt 0.000000 0.593750
|
||||
vt 0.245939 0.593750
|
||||
vt 0.254061 0.593750
|
||||
vt 0.745939 0.593750
|
||||
vt 0.754061 0.593750
|
||||
vt 1.000000 0.593750
|
||||
# 13 (верх.)
|
||||
vt 0.000000 0.406250
|
||||
vt 0.245939 0.406250
|
||||
vt 0.254061 0.406250
|
||||
vt 0.745939 0.406250
|
||||
vt 0.754061 0.406250
|
||||
vt 1.000000 0.406250
|
||||
vt 0.000000 0.593750
|
||||
vt 0.168274 0.593750
|
||||
vt 0.331726 0.593750
|
||||
vt 0.668274 0.593750
|
||||
vt 0.831726 0.593750
|
||||
vt 1.000000 0.593750
|
||||
# 25 (внутр.)
|
||||
vt 1.000000 0.093750
|
||||
vt 0.831726 0.093750
|
||||
vt 0.668274 0.093750
|
||||
vt 0.331726 0.093750
|
||||
vt 0.168274 0.093750
|
||||
vt 0.000000 0.093750
|
||||
vt 1.000000 -0.031250
|
||||
vt 0.831726 -0.031250
|
||||
vt 0.668274 -0.031250
|
||||
vt 0.331726 -0.031250
|
||||
vt 0.168274 -0.031250
|
||||
vt 0.000000 -0.031250
|
||||
# 37 (внеш.)
|
||||
vt 0.000000 -0.031250
|
||||
vt 0.245939 -0.031250
|
||||
vt 0.254061 -0.031250
|
||||
vt 0.745939 -0.031250
|
||||
vt 0.754061 -0.031250
|
||||
vt 1.000000 -0.031250
|
||||
vt 0.000000 0.093750
|
||||
vt 0.245939 0.093750
|
||||
vt 0.254061 0.093750
|
||||
vt 0.745939 0.093750
|
||||
vt 0.754061 0.093750
|
||||
vt 1.000000 0.093750
|
||||
# 49 (торец)
|
||||
vt 0.406250 -0.031250
|
||||
vt 0.406250 0.093750
|
||||
vt 0.593750 -0.031250
|
||||
vt 0.593750 0.093750
|
||||
# Нормали
|
||||
# 1
|
||||
vn 1.000000 0.000000 0.000000
|
||||
vn 0.000000 1.000000 0.000000
|
||||
vn 0.000000 0.000000 1.000000
|
||||
vn 0.707107 0.000000 0.707107
|
||||
# 5
|
||||
vn -1.000000 0.000000 0.000000
|
||||
vn 0.000000 -1.000000 0.000000
|
||||
vn 0.000000 0.000000 -1.000000
|
||||
vn -0.707107 0.000000 -0.707107
|
||||
# Грани
|
||||
g Sides1
|
||||
# Часть 1
|
||||
f 5/37/1 6/38/1 14/44/1
|
||||
f 5/37/1 14/44/1 13/43/1
|
||||
f 13/13/2 14/14/2 10/20/2
|
||||
f 13/13/2 10/20/2 9/19/2
|
||||
f 9/25/5 10/26/5 2/32/5
|
||||
f 9/25/5 2/32/5 1/31/5
|
||||
f 1/1/6 2/2/6 6/8/6
|
||||
f 1/1/6 6/8/6 5/7/6
|
||||
# Часть 2
|
||||
f 6/39/4 7/40/4 15/46/4
|
||||
f 6/39/4 15/46/4 14/45/4
|
||||
f 14/15/2 15/16/2 11/22/2
|
||||
f 14/15/2 11/22/2 10/21/2
|
||||
f 10/27/8 11/28/8 3/34/8
|
||||
f 10/27/8 3/34/8 2/33/8
|
||||
f 2/3/6 3/4/6 7/10/6
|
||||
f 2/3/6 7/10/6 6/9/6
|
||||
# Часть 3
|
||||
f 7/41/3 8/42/3 16/48/3
|
||||
f 7/41/3 16/48/3 15/47/3
|
||||
f 15/17/2 16/18/2 12/24/2
|
||||
f 15/17/2 12/24/2 11/23/2
|
||||
f 11/29/7 12/30/7 4/36/7
|
||||
f 11/29/7 4/36/7 3/35/7
|
||||
f 3/5/6 4/6/6 8/12/6
|
||||
f 3/5/6 8/12/6 7/11/6
|
||||
g Ends1
|
||||
f 1/49/3 5/51/3 13/52/3
|
||||
f 1/49/3 13/52/3 9/50/3
|
||||
f 4/49/1 12/50/1 16/52/1
|
||||
f 4/49/1 16/52/1 8/51/1
|
||||
@ -1,180 +0,0 @@
|
||||
# Вершины
|
||||
# Провод 1
|
||||
# 1 (ниж. внутр.)
|
||||
v 0.093750 -0.531250 -0.501000
|
||||
v 0.093750 -0.531250 -0.331726
|
||||
v 0.331726 -0.531250 -0.093750
|
||||
v 0.501000 -0.531250 -0.093750
|
||||
# 5 (ниж. наруж.)
|
||||
v -0.093750 -0.531250 -0.501000
|
||||
v -0.093750 -0.531250 -0.254061
|
||||
v 0.254061 -0.531250 0.093750
|
||||
v 0.501000 -0.531250 0.093750
|
||||
# 9 (верх. внутр.)
|
||||
v 0.093750 -0.406250 -0.501000
|
||||
v 0.093750 -0.406250 -0.331726
|
||||
v 0.331726 -0.406250 -0.093750
|
||||
v 0.501000 -0.406250 -0.093750
|
||||
# 13 (верх. наруж.)
|
||||
v -0.093750 -0.406250 -0.501000
|
||||
v -0.093750 -0.406250 -0.254061
|
||||
v 0.254061 -0.406250 0.093750
|
||||
v 0.501000 -0.406250 0.093750
|
||||
# Провод 2
|
||||
# 17 (ниж. внутр.)
|
||||
v -0.093750 -0.531250 0.501000
|
||||
v -0.093750 -0.531250 0.331726
|
||||
v -0.331726 -0.531250 0.093750
|
||||
v -0.501000 -0.531250 0.093750
|
||||
# 21 (ниж. наруж.)
|
||||
v 0.093750 -0.531250 0.501000
|
||||
v 0.093750 -0.531250 0.254061
|
||||
v -0.254061 -0.531250 -0.093750
|
||||
v -0.501000 -0.531250 -0.093750
|
||||
# 25 (верх. внутр.)
|
||||
v -0.093750 -0.406250 0.501000
|
||||
v -0.093750 -0.406250 0.331726
|
||||
v -0.331726 -0.406250 0.093750
|
||||
v -0.501000 -0.406250 0.093750
|
||||
# 29 (верх. наруж.)
|
||||
v 0.093750 -0.406250 0.501000
|
||||
v 0.093750 -0.406250 0.254061
|
||||
v -0.254061 -0.406250 -0.093750
|
||||
v -0.501000 -0.406250 -0.093750
|
||||
# Текстурные координаты
|
||||
# 1 (ниж.)
|
||||
vt 0.000000 0.406250
|
||||
vt 0.168274 0.406250
|
||||
vt 0.331726 0.406250
|
||||
vt 0.668274 0.406250
|
||||
vt 0.831726 0.406250
|
||||
vt 1.000000 0.406250
|
||||
vt 0.000000 0.593750
|
||||
vt 0.245939 0.593750
|
||||
vt 0.254061 0.593750
|
||||
vt 0.745939 0.593750
|
||||
vt 0.754061 0.593750
|
||||
vt 1.000000 0.593750
|
||||
# 13 (верх.)
|
||||
vt 0.000000 0.406250
|
||||
vt 0.245939 0.406250
|
||||
vt 0.254061 0.406250
|
||||
vt 0.745939 0.406250
|
||||
vt 0.754061 0.406250
|
||||
vt 1.000000 0.406250
|
||||
vt 0.000000 0.593750
|
||||
vt 0.168274 0.593750
|
||||
vt 0.331726 0.593750
|
||||
vt 0.668274 0.593750
|
||||
vt 0.831726 0.593750
|
||||
vt 1.000000 0.593750
|
||||
# 25 (внутр.)
|
||||
vt 1.000000 0.093750
|
||||
vt 0.831726 0.093750
|
||||
vt 0.668274 0.093750
|
||||
vt 0.331726 0.093750
|
||||
vt 0.168274 0.093750
|
||||
vt 0.000000 0.093750
|
||||
vt 1.000000 -0.031250
|
||||
vt 0.831726 -0.031250
|
||||
vt 0.668274 -0.031250
|
||||
vt 0.331726 -0.031250
|
||||
vt 0.168274 -0.031250
|
||||
vt 0.000000 -0.031250
|
||||
# 37 (внеш.)
|
||||
vt 0.000000 -0.031250
|
||||
vt 0.245939 -0.031250
|
||||
vt 0.254061 -0.031250
|
||||
vt 0.745939 -0.031250
|
||||
vt 0.754061 -0.031250
|
||||
vt 1.000000 -0.031250
|
||||
vt 0.000000 0.093750
|
||||
vt 0.245939 0.093750
|
||||
vt 0.254061 0.093750
|
||||
vt 0.745939 0.093750
|
||||
vt 0.754061 0.093750
|
||||
vt 1.000000 0.093750
|
||||
# 49 (торец)
|
||||
vt 0.406250 -0.031250
|
||||
vt 0.406250 0.093750
|
||||
vt 0.593750 -0.031250
|
||||
vt 0.593750 0.093750
|
||||
# Нормали
|
||||
# 1
|
||||
vn 1.000000 0.000000 0.000000
|
||||
vn 0.000000 1.000000 0.000000
|
||||
vn 0.000000 0.000000 1.000000
|
||||
vn 0.707107 0.000000 0.707107
|
||||
# 5
|
||||
vn -1.000000 0.000000 0.000000
|
||||
vn 0.000000 -1.000000 0.000000
|
||||
vn 0.000000 0.000000 -1.000000
|
||||
vn -0.707107 0.000000 -0.707107
|
||||
# Грани
|
||||
# Грани
|
||||
g Sides1
|
||||
# Часть 1
|
||||
f 5/37/1 6/38/1 14/44/1
|
||||
f 5/37/1 14/44/1 13/43/1
|
||||
f 13/13/2 14/14/2 10/20/2
|
||||
f 13/13/2 10/20/2 9/19/2
|
||||
f 9/25/5 10/26/5 2/32/5
|
||||
f 9/25/5 2/32/5 1/31/5
|
||||
f 1/1/6 2/2/6 6/8/6
|
||||
f 1/1/6 6/8/6 5/7/6
|
||||
# Часть 2
|
||||
f 6/39/4 7/40/4 15/46/4
|
||||
f 6/39/4 15/46/4 14/45/4
|
||||
f 14/15/2 15/16/2 11/22/2
|
||||
f 14/15/2 11/22/2 10/21/2
|
||||
f 10/27/8 11/28/8 3/34/8
|
||||
f 10/27/8 3/34/8 2/33/8
|
||||
f 2/3/6 3/4/6 7/10/6
|
||||
f 2/3/6 7/10/6 6/9/6
|
||||
# Часть 3
|
||||
f 7/41/3 8/42/3 16/48/3
|
||||
f 7/41/3 16/48/3 15/47/3
|
||||
f 15/17/2 16/18/2 12/24/2
|
||||
f 15/17/2 12/24/2 11/23/2
|
||||
f 11/29/7 12/30/7 4/36/7
|
||||
f 11/29/7 4/36/7 3/35/7
|
||||
f 3/5/6 4/6/6 8/12/6
|
||||
f 3/5/6 8/12/6 7/11/6
|
||||
g Ends1
|
||||
f 1/49/3 5/51/3 13/52/3
|
||||
f 1/49/3 13/52/3 9/50/3
|
||||
f 4/49/1 12/50/1 16/52/1
|
||||
f 4/49/1 16/52/1 8/51/1
|
||||
g Sides2
|
||||
# Часть 1
|
||||
f 21/37/1 22/38/1 30/44/1
|
||||
f 21/37/1 30/44/1 29/43/1
|
||||
f 29/13/2 30/14/2 26/20/2
|
||||
f 29/13/2 26/20/2 25/19/2
|
||||
f 25/25/5 26/26/5 18/32/5
|
||||
f 25/25/5 18/32/5 17/31/5
|
||||
f 17/1/6 18/2/6 22/8/6
|
||||
f 17/1/6 22/8/6 21/7/6
|
||||
# Часть 2
|
||||
f 22/39/4 23/40/4 31/46/4
|
||||
f 22/39/4 31/46/4 30/45/4
|
||||
f 30/15/2 31/16/2 27/22/2
|
||||
f 30/15/2 27/22/2 26/21/2
|
||||
f 26/27/8 27/28/8 19/34/8
|
||||
f 26/27/8 19/34/8 18/33/8
|
||||
f 18/3/6 19/4/6 23/10/6
|
||||
f 18/3/6 23/10/6 22/9/6
|
||||
# Часть 3
|
||||
f 23/41/3 24/42/3 32/48/3
|
||||
f 23/41/3 32/48/3 31/47/3
|
||||
f 31/17/2 32/18/2 28/24/2
|
||||
f 31/17/2 28/24/2 27/23/2
|
||||
f 27/29/7 28/30/7 20/36/7
|
||||
f 27/29/7 20/36/7 19/35/7
|
||||
f 19/5/6 20/6/6 24/12/6
|
||||
f 19/5/6 24/12/6 23/11/6
|
||||
g Ends2
|
||||
f 17/49/3 21/51/3 29/52/3
|
||||
f 17/49/3 29/52/3 25/50/3
|
||||
f 20/49/1 28/50/1 32/52/1
|
||||
f 20/49/1 32/52/1 24/51/1
|
||||
@ -1,3 +1,5 @@
|
||||
local screwdriver_exists = minetest.global_exists("screwdriver")
|
||||
|
||||
local tjunction_nodebox = {
|
||||
type = "fixed",
|
||||
-- ±0.001 is to prevent z-fighting
|
||||
@ -10,11 +12,18 @@ local tjunction_selectionbox = {
|
||||
fixed = { -16/32, -16/32, -16/32, 16/32, -12/32, 7/32 },
|
||||
}
|
||||
|
||||
local tjunction_get_rules = mesecon.horiz_rules_getter({
|
||||
{x = 1, y = 0, z = 0},
|
||||
{x = 0, y = 0, z = -1},
|
||||
{x = -1, y = 0, z = 0},
|
||||
})
|
||||
local tjunction_get_rules = function (node)
|
||||
local rules =
|
||||
{{x = 0, y = 0, z = 1},
|
||||
{x = 1, y = 0, z = 0},
|
||||
{x = 0, y = 0, z = -1}}
|
||||
|
||||
for i = 0, node.param2 do
|
||||
rules = mesecon.rotate_rules_left(rules)
|
||||
end
|
||||
|
||||
return rules
|
||||
end
|
||||
|
||||
minetest.register_node("mesecons_extrawires:tjunction_on", {
|
||||
drawtype = "nodebox",
|
||||
@ -35,7 +44,7 @@ minetest.register_node("mesecons_extrawires:tjunction_on", {
|
||||
node_box = tjunction_nodebox,
|
||||
groups = {dig_immediate = 3, not_in_creative_inventory = 1},
|
||||
drop = "mesecons_extrawires:tjunction_off",
|
||||
sounds = mesecon.node_sound.default,
|
||||
sounds = default.node_sound_defaults(),
|
||||
mesecons = {conductor =
|
||||
{
|
||||
state = mesecon.state.on,
|
||||
@ -43,7 +52,7 @@ minetest.register_node("mesecons_extrawires:tjunction_on", {
|
||||
offstate = "mesecons_extrawires:tjunction_off"
|
||||
}},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
on_rotate = mesecon.on_rotate_horiz,
|
||||
on_rotate = screwdriver_exists and screwdriver.rotate_simple,
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_extrawires:tjunction_off", {
|
||||
@ -65,7 +74,7 @@ minetest.register_node("mesecons_extrawires:tjunction_off", {
|
||||
selection_box = tjunction_selectionbox,
|
||||
node_box = tjunction_nodebox,
|
||||
groups = {dig_immediate = 3},
|
||||
sounds = mesecon.node_sound.default,
|
||||
sounds = default.node_sound_defaults(),
|
||||
mesecons = {conductor =
|
||||
{
|
||||
state = mesecon.state.off,
|
||||
@ -73,5 +82,14 @@ minetest.register_node("mesecons_extrawires:tjunction_off", {
|
||||
onstate = "mesecons_extrawires:tjunction_on"
|
||||
}},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
on_rotate = mesecon.on_rotate_horiz,
|
||||
on_rotate = screwdriver_exists and screwdriver.rotate_simple,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_extrawires:tjunction_off 3",
|
||||
recipe = {
|
||||
{"", "", ""},
|
||||
{"mesecons_insulated:insulated_off", "mesecons_insulated:insulated_off", "mesecons_insulated:insulated_off"},
|
||||
{"", "mesecons_insulated:insulated_off", ""},
|
||||
}
|
||||
})
|
||||
|
||||
@ -69,7 +69,7 @@ local vertical_updatepos = function (pos)
|
||||
end
|
||||
end
|
||||
|
||||
local vertical_update = function (pos)
|
||||
local vertical_update = function (pos, node)
|
||||
vertical_updatepos(pos) -- this one
|
||||
vertical_updatepos(vector.add(pos, vertical_rules[1])) -- above
|
||||
vertical_updatepos(vector.add(pos, vertical_rules[2])) -- below
|
||||
@ -89,7 +89,7 @@ mesecon.register_node("mesecons_extrawires:vertical", {
|
||||
drop = "mesecons_extrawires:vertical_off",
|
||||
after_place_node = vertical_update,
|
||||
after_dig_node = vertical_update,
|
||||
sounds = mesecon.node_sound.default,
|
||||
sounds = default.node_sound_defaults(),
|
||||
},{
|
||||
tiles = {"mesecons_wire_off.png"},
|
||||
groups = {dig_immediate=3},
|
||||
@ -123,7 +123,7 @@ mesecon.register_node("mesecons_extrawires:vertical_top", {
|
||||
drop = "mesecons_extrawires:vertical_off",
|
||||
after_place_node = vertical_update,
|
||||
after_dig_node = vertical_update,
|
||||
sounds = mesecon.node_sound.default,
|
||||
sounds = default.node_sound_defaults(),
|
||||
},{
|
||||
tiles = {"mesecons_wire_off.png"},
|
||||
mesecons = {conductor = {
|
||||
@ -155,7 +155,7 @@ mesecon.register_node("mesecons_extrawires:vertical_bottom", {
|
||||
drop = "mesecons_extrawires:vertical_off",
|
||||
after_place_node = vertical_update,
|
||||
after_dig_node = vertical_update,
|
||||
sounds = mesecon.node_sound.default,
|
||||
sounds = default.node_sound_defaults(),
|
||||
},{
|
||||
tiles = {"mesecons_wire_off.png"},
|
||||
mesecons = {conductor = {
|
||||
@ -170,4 +170,18 @@ mesecon.register_node("mesecons_extrawires:vertical_bottom", {
|
||||
offstate = "mesecons_extrawires:vertical_bottom_off",
|
||||
rules = bottom_rules,
|
||||
}}
|
||||
})
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_extrawires:vertical_off 3",
|
||||
recipe = {
|
||||
{"mesecons:wire_00000000_off"},
|
||||
{"mesecons:wire_00000000_off"},
|
||||
{"mesecons:wire_00000000_off"}
|
||||
}
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons:wire_00000000_off",
|
||||
recipe = {{"mesecons_extrawires:vertical_off"}}
|
||||
})
|
||||
|
||||
2
mesecons_fpga/depends.txt
Normal file
2
mesecons_fpga/depends.txt
Normal file
@ -0,0 +1,2 @@
|
||||
mesecons
|
||||
screwdriver?
|
||||
@ -1,11 +1,10 @@
|
||||
local plg = {}
|
||||
plg.rules = {}
|
||||
-- per-player formspec positions
|
||||
plg.open_formspecs = {}
|
||||
|
||||
local lcore = dofile(minetest.get_modpath(minetest.get_current_modname()) .. "/logic.lua")
|
||||
dofile(minetest.get_modpath(minetest.get_current_modname()) .. "/tool.lua")(plg)
|
||||
|
||||
|
||||
plg.register_nodes = function(template)
|
||||
-- each loop is for one of the 4 IO ports
|
||||
for a = 0, 1 do
|
||||
@ -94,43 +93,32 @@ plg.register_nodes({
|
||||
|
||||
meta:set_string("instr", lcore.serialize(is))
|
||||
meta:set_int("valid", 0)
|
||||
meta:set_string("formspec", plg.to_formspec_string(is))
|
||||
meta:set_string("infotext", "FPGA")
|
||||
end,
|
||||
on_rightclick = function(pos, _, clicker)
|
||||
if not minetest.is_player(clicker) then
|
||||
return
|
||||
end
|
||||
on_receive_fields = function(pos, formname, fields, sender)
|
||||
if fields.program == nil then return end -- we only care when the user clicks "Program"
|
||||
local meta = minetest.get_meta(pos)
|
||||
local name = clicker:get_player_name()
|
||||
-- Erase formspecs of old FPGAs
|
||||
meta:set_string("formspec", "")
|
||||
local is = plg.from_formspec_fields(fields)
|
||||
|
||||
plg.open_formspecs[name] = pos
|
||||
local is = lcore.deserialize(meta:get_string("instr"))
|
||||
minetest.show_formspec(name, "mesecons:fpga", plg.to_formspec_string(is, nil))
|
||||
meta:set_string("instr", lcore.serialize(is))
|
||||
plg.update_formspec(pos, is)
|
||||
end,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {
|
||||
effector = {
|
||||
rules = {}, -- replaced later
|
||||
action_change = function(pos, _, rule, newstate)
|
||||
if plg.ports_changed(pos, rule, newstate) then
|
||||
plg.update(pos)
|
||||
end
|
||||
action_change = function(pos, node, rule, newstate)
|
||||
plg.ports_changed(pos, rule, newstate)
|
||||
plg.update(pos)
|
||||
end
|
||||
}
|
||||
},
|
||||
after_dig_node = function(pos, node)
|
||||
mesecon.receptor_off(pos, plg.rules[node.name])
|
||||
for name, open_pos in pairs(plg.open_formspecs) do
|
||||
if vector.equals(pos, open_pos) then
|
||||
minetest.close_formspec(name, "mesecons:fpga")
|
||||
plg.open_formspecs[name] = nil
|
||||
end
|
||||
end
|
||||
end,
|
||||
on_blast = mesecon.on_blastnode,
|
||||
on_rotate = function(pos, _, user, mode)
|
||||
on_rotate = function(pos, node, user, mode)
|
||||
local abcd1 = {"A", "B", "C", "D"}
|
||||
local abcd2 = {A = 1, B = 2, C = 3, D = 4}
|
||||
local ops = {"op1", "op2", "dst"}
|
||||
@ -165,12 +153,13 @@ plg.register_nodes({
|
||||
end
|
||||
|
||||
meta:set_string("instr", lcore.serialize(instr))
|
||||
plg.update_meta(pos, instr)
|
||||
plg.update_formspec(pos, instr)
|
||||
return true
|
||||
end,
|
||||
})
|
||||
|
||||
plg.to_formspec_string = function(is, err)
|
||||
|
||||
plg.to_formspec_string = function(is)
|
||||
local function dropdown_op(x, y, name, val)
|
||||
local s = "dropdown[" .. tostring(x) .. "," .. tostring(y) .. ";"
|
||||
.. "0.75,0.5;" .. name .. ";" -- the height seems to be ignored?
|
||||
@ -191,20 +180,26 @@ plg.to_formspec_string = function(is, err)
|
||||
return s .. "]"
|
||||
end
|
||||
local function dropdown_action(x, y, name, val)
|
||||
local selected = 0
|
||||
local titles = { " " }
|
||||
for i, data in ipairs(lcore.get_operations()) do
|
||||
titles[i + 1] = data.fs_name
|
||||
if val == data.gate then
|
||||
selected = i + 1
|
||||
end
|
||||
local s = "dropdown[" .. tostring(x) .. "," .. tostring(y) .. ";"
|
||||
.. "1.125,0.5;" .. name .. ";" -- the height seems to be ignored?
|
||||
s = s .. " , AND, OR, NOT, XOR,NAND, =,XNOR;"
|
||||
if val == nil then
|
||||
return s .. "0]" -- actually selects no field at all
|
||||
end
|
||||
return ("dropdown[%f,%f;1.125,0.5;%s;%s;%i]"):format(
|
||||
x, y, name, table.concat(titles, ","), selected)
|
||||
local mapping = {
|
||||
["and"] = 1,
|
||||
["or"] = 2,
|
||||
["not"] = 3,
|
||||
["xor"] = 4,
|
||||
["nand"] = 5,
|
||||
["buf"] = 6,
|
||||
["xnor"] = 7,
|
||||
}
|
||||
return s .. tostring(1 + mapping[val]) .. "]"
|
||||
end
|
||||
local s = "size[9,9]"..
|
||||
"label[3.4,-0.15;FPGA gate configuration]"..
|
||||
"button[7,7.5;2,2.5;program;Program]"..
|
||||
"button_exit[7,7.5;2,2.5;program;Program]"..
|
||||
"box[4.2,0.5;0.03,7;#ffffff]"..
|
||||
"label[0.25,0.25;op. 1]"..
|
||||
"label[1.0,0.25;gate type]"..
|
||||
@ -230,12 +225,6 @@ plg.to_formspec_string = function(is, err)
|
||||
y = 1 - 0.25
|
||||
end
|
||||
end
|
||||
if err then
|
||||
local fmsg = minetest.colorize("#ff0000", minetest.formspec_escape(err.msg))
|
||||
s = s .. plg.red_box_around(err.i) ..
|
||||
"label[0.25,8.25;The gate configuration is erroneous in the marked area:]"..
|
||||
"label[0.25,8.5;" .. fmsg .. "]"
|
||||
end
|
||||
return s
|
||||
end
|
||||
|
||||
@ -250,11 +239,20 @@ plg.from_formspec_fields = function(fields)
|
||||
end
|
||||
end
|
||||
local function read_action(s)
|
||||
for i, data in ipairs(lcore.get_operations()) do
|
||||
if data.fs_name == s then
|
||||
return data.gate
|
||||
end
|
||||
if s == nil or s == " " then
|
||||
return nil
|
||||
end
|
||||
local mapping = {
|
||||
["AND"] = "and",
|
||||
["OR"] = "or",
|
||||
["NOT"] = "not",
|
||||
["XOR"] = "xor",
|
||||
["NAND"] = "nand",
|
||||
["="] = "buf",
|
||||
["XNOR"] = "xnor",
|
||||
}
|
||||
s = s:gsub("^%s*", "") -- remove leading spaces
|
||||
return mapping[s]
|
||||
end
|
||||
local is = {}
|
||||
for i = 1, 14 do
|
||||
@ -268,11 +266,12 @@ plg.from_formspec_fields = function(fields)
|
||||
return is
|
||||
end
|
||||
|
||||
plg.update_meta = function(pos, is)
|
||||
plg.update_formspec = function(pos, is)
|
||||
if type(is) == "string" then -- serialized string
|
||||
is = lcore.deserialize(is)
|
||||
end
|
||||
local meta = minetest.get_meta(pos)
|
||||
local form = plg.to_formspec_string(is)
|
||||
|
||||
local err = lcore.validate(is)
|
||||
if err == nil then
|
||||
@ -281,20 +280,17 @@ plg.update_meta = function(pos, is)
|
||||
else
|
||||
meta:set_int("valid", 0)
|
||||
meta:set_string("infotext", "FPGA")
|
||||
local fmsg = minetest.colorize("#ff0000", minetest.formspec_escape(err.msg))
|
||||
form = form .. plg.red_box_around(err.i) ..
|
||||
"label[0.25,8.25;The gate configuration is erroneous in the marked area:]"..
|
||||
"label[0.25,8.5;" .. fmsg .. "]"
|
||||
end
|
||||
|
||||
meta:set_string("formspec", form)
|
||||
|
||||
-- reset ports and run programmed logic
|
||||
plg.setports(pos, false, false, false, false)
|
||||
plg.update(pos)
|
||||
|
||||
-- Refresh open formspecs
|
||||
local form = plg.to_formspec_string(is, err)
|
||||
for name, open_pos in pairs(plg.open_formspecs) do
|
||||
if vector.equals(pos, open_pos) then
|
||||
minetest.show_formspec(name, "mesecons:fpga", form)
|
||||
end
|
||||
end
|
||||
return err
|
||||
end
|
||||
|
||||
plg.red_box_around = function(i)
|
||||
@ -327,10 +323,8 @@ plg.update = function(pos)
|
||||
plg.setports(pos, A, B, C, D)
|
||||
end
|
||||
|
||||
-- Updates the port states according to the signal change.
|
||||
-- Returns whether the port states actually changed.
|
||||
plg.ports_changed = function(pos, rule, newstate)
|
||||
if rule == nil then return false end
|
||||
if rule == nil then return end
|
||||
local meta = minetest.get_meta(pos)
|
||||
local states
|
||||
|
||||
@ -350,14 +344,10 @@ plg.ports_changed = function(pos, rule, newstate)
|
||||
local portno = ({4, 1, nil, 3, 2})[3 + rule.x + 2*rule.z]
|
||||
states[portno] = (newstate == "on")
|
||||
|
||||
local new_portstates =
|
||||
meta:set_string("portstates",
|
||||
(states[1] and "1" or "0") .. (states[2] and "1" or "0") ..
|
||||
(states[3] and "1" or "0") .. (states[4] and "1" or "0")
|
||||
if new_portstates ~= s then
|
||||
meta:set_string("portstates", new_portstates)
|
||||
return true
|
||||
end
|
||||
return false
|
||||
)
|
||||
end
|
||||
|
||||
plg.getports = function(pos) -- gets merged states of INPUT & OUTPUT
|
||||
@ -419,35 +409,12 @@ plg.setports = function(pos, A, B, C, D) -- sets states of OUTPUT
|
||||
end
|
||||
end
|
||||
|
||||
minetest.register_on_player_receive_fields(function(player, formname, fields)
|
||||
local player_name = player:get_player_name()
|
||||
|
||||
if formname ~= "mesecons:fpga" or fields.quit then
|
||||
plg.open_formspecs[player_name] = nil -- potential garbage
|
||||
return
|
||||
end
|
||||
if not fields.program then
|
||||
return -- we only care when the user clicks "Program"
|
||||
end
|
||||
local pos = plg.open_formspecs[player_name]
|
||||
if minetest.is_protected(pos, player_name) then
|
||||
minetest.record_protection_violation(pos, player_name)
|
||||
return
|
||||
end
|
||||
|
||||
local meta = minetest.get_meta(pos)
|
||||
local is = plg.from_formspec_fields(fields)
|
||||
|
||||
meta:set_string("instr", lcore.serialize(is))
|
||||
local err = plg.update_meta(pos, is)
|
||||
|
||||
if not err then
|
||||
plg.open_formspecs[player_name] = nil
|
||||
-- Close on success
|
||||
minetest.close_formspec(player_name, "mesecons:fpga")
|
||||
end
|
||||
end)
|
||||
|
||||
minetest.register_on_leaveplayer(function(player)
|
||||
plg.open_formspecs[player:get_player_name()] = nil
|
||||
end)
|
||||
minetest.register_craft({
|
||||
output = "mesecons_fpga:fpga0000 2",
|
||||
recipe = {
|
||||
{'group:mesecon_conductor_craftable', 'group:mesecon_conductor_craftable'},
|
||||
{'mesecons_materials:silicon', 'mesecons_materials:silicon'},
|
||||
{'group:mesecon_conductor_craftable', 'group:mesecon_conductor_craftable'},
|
||||
}
|
||||
})
|
||||
|
||||
@ -1,27 +1,5 @@
|
||||
|
||||
local lg = {}
|
||||
|
||||
local operations = {
|
||||
-- table index: Index in the formspec dropdown
|
||||
-- gate: Internal name
|
||||
-- short: Serialized form, single character
|
||||
-- fs_name: Display name, padded to 4 characters
|
||||
-- func: Function that applies the operation
|
||||
-- unary: Whether this gate only has one input
|
||||
{ gate = "and", short = "&", fs_name = " AND", func = function(a, b) return a and b end },
|
||||
{ gate = "or", short = "|", fs_name = " OR", func = function(a, b) return a or b end },
|
||||
{ gate = "not", short = "~", fs_name = " NOT", func = function(_, b) return not b end, unary = true },
|
||||
{ gate = "xor", short = "^", fs_name = " XOR", func = function(a, b) return a ~= b end },
|
||||
{ gate = "nand", short = "?", fs_name = "NAND", func = function(a, b) return not (a and b) end },
|
||||
{ gate = "buf", short = "_", fs_name = " =", func = function(_, b) return b end, unary = true },
|
||||
{ gate = "xnor", short = "=", fs_name = "XNOR", func = function(a, b) return a == b end },
|
||||
{ gate = "nor", short = "!", fs_name = " NOR", func = function(a, b) return not (a or b) end },
|
||||
}
|
||||
|
||||
lg.get_operations = function()
|
||||
return operations
|
||||
end
|
||||
|
||||
-- (de)serialize
|
||||
lg.serialize = function(t)
|
||||
local function _op(t)
|
||||
@ -33,14 +11,20 @@ lg.serialize = function(t)
|
||||
return tostring(t.n)
|
||||
end
|
||||
end
|
||||
-- Serialize actions (gates) from eg. "and" to "&"
|
||||
local function _action(action)
|
||||
for i, data in ipairs(operations) do
|
||||
if data.gate == action then
|
||||
return data.short
|
||||
end
|
||||
local function _action(s)
|
||||
if s == nil then
|
||||
return " "
|
||||
end
|
||||
return " "
|
||||
local mapping = {
|
||||
["and"] = "&",
|
||||
["or"] = "|",
|
||||
["not"] = "~",
|
||||
["xor"] = "^",
|
||||
["nand"] = "?", --dunno
|
||||
["buf"] = "_",
|
||||
["xnor"] = "=",
|
||||
}
|
||||
return mapping[s]
|
||||
end
|
||||
|
||||
local s = ""
|
||||
@ -64,14 +48,18 @@ lg.deserialize = function(s)
|
||||
return {type = "reg", n = tonumber(c)}
|
||||
end
|
||||
end
|
||||
-- Deserialize actions (gates) from eg. "&" to "and"
|
||||
local function _action(action)
|
||||
for i, data in ipairs(operations) do
|
||||
if data.short == action then
|
||||
return data.gate
|
||||
end
|
||||
end
|
||||
-- nil
|
||||
local function _action(c)
|
||||
local mapping = {
|
||||
["&"] = "and",
|
||||
["|"] = "or",
|
||||
["~"] = "not",
|
||||
["^"] = "xor",
|
||||
["?"] = "nand",
|
||||
["_"] = "buf",
|
||||
["="] = "xnor",
|
||||
[" "] = nil,
|
||||
}
|
||||
return mapping[c]
|
||||
end
|
||||
|
||||
local ret = {}
|
||||
@ -121,25 +109,16 @@ lg.validate_single = function(t, i)
|
||||
return false
|
||||
end
|
||||
local elem = t[i]
|
||||
|
||||
local gate_data
|
||||
for j, data in ipairs(operations) do
|
||||
if data.gate == elem.action then
|
||||
gate_data = data
|
||||
break
|
||||
end
|
||||
end
|
||||
|
||||
-- check for completeness
|
||||
if not gate_data then
|
||||
return {i = i, msg = "Gate type is required"}
|
||||
elseif gate_data.unary then
|
||||
if elem.action == nil then
|
||||
return {i = i, msg = "Gate type required"}
|
||||
elseif elem.action == "not" or elem.action == "buf" then
|
||||
if elem.op1 ~= nil or elem.op2 == nil or elem.dst == nil then
|
||||
return {i = i, msg = "Second operand (only) and destination are required"}
|
||||
return {i = i, msg = "Second operand (only) and destination required"}
|
||||
end
|
||||
else
|
||||
if elem.op1 == nil or elem.op2 == nil or elem.dst == nil then
|
||||
return {i = i, msg = "Operands and destination are required"}
|
||||
return {i = i, msg = "Operands and destination required"}
|
||||
end
|
||||
end
|
||||
-- check whether operands/destination are identical
|
||||
@ -180,12 +159,21 @@ end
|
||||
-- interpreter
|
||||
lg.interpret = function(t, a, b, c, d)
|
||||
local function _action(s, v1, v2)
|
||||
for i, data in ipairs(operations) do
|
||||
if data.gate == s then
|
||||
return data.func(v1, v2)
|
||||
end
|
||||
if s == "and" then
|
||||
return v1 and v2
|
||||
elseif s == "or" then
|
||||
return v1 or v2
|
||||
elseif s == "not" then
|
||||
return not v2
|
||||
elseif s == "xor" then
|
||||
return v1 ~= v2
|
||||
elseif s == "nand" then
|
||||
return not (v1 and v2)
|
||||
elseif s == "buf" then
|
||||
return v2
|
||||
else -- s == "xnor"
|
||||
return v1 == v2
|
||||
end
|
||||
return false -- unknown gate
|
||||
end
|
||||
local function _op(t, regs, io_in)
|
||||
if t.type == "reg" then
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_fpga
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -18,13 +18,11 @@ minetest.register_tool("mesecons_fpga:programmer", {
|
||||
local meta = minetest.get_meta(pos)
|
||||
if meta:get_string("instr") == "//////////////" then
|
||||
minetest.chat_send_player(placer:get_player_name(), "This FPGA is unprogrammed.")
|
||||
minetest.sound_play("mesecons_fpga_fail", { pos = placer:get_pos(), gain = 0.1, max_hear_distance = 4 }, true)
|
||||
return itemstack
|
||||
end
|
||||
itemstack:set_metadata(meta:get_string("instr"))
|
||||
minetest.chat_send_player(placer:get_player_name(), "FPGA gate configuration was successfully copied!")
|
||||
minetest.sound_play("mesecons_fpga_copy", { pos = placer:get_pos(), gain = 0.1, max_hear_distance = 4 }, true)
|
||||
|
||||
|
||||
return itemstack
|
||||
end,
|
||||
on_use = function(itemstack, user, pointed_thing)
|
||||
@ -36,27 +34,29 @@ minetest.register_tool("mesecons_fpga:programmer", {
|
||||
if minetest.get_node(pos).name:find("mesecons_fpga:fpga") ~= 1 then
|
||||
return itemstack
|
||||
end
|
||||
local player_name = user:get_player_name()
|
||||
if minetest.is_protected(pos, player_name) then
|
||||
minetest.record_protection_violation(pos, player_name)
|
||||
return itemstack
|
||||
end
|
||||
|
||||
local imeta = itemstack:get_metadata()
|
||||
if imeta == "" then
|
||||
minetest.chat_send_player(player_name, "Use shift+right-click to copy a gate configuration first.")
|
||||
minetest.sound_play("mesecons_fpga_fail", { pos = user:get_pos(), gain = 0.1, max_hear_distance = 4 }, true)
|
||||
minetest.chat_send_player(user:get_player_name(), "Use shift+right-click to copy a gate configuration first.")
|
||||
return itemstack
|
||||
end
|
||||
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_string("instr", imeta)
|
||||
plg.update_meta(pos, imeta)
|
||||
minetest.chat_send_player(player_name, "Gate configuration was successfully written to FPGA!")
|
||||
minetest.sound_play("mesecons_fpga_write", { pos = user:get_pos(), gain = 0.1, max_hear_distance = 4 }, true)
|
||||
plg.update_formspec(pos, imeta)
|
||||
minetest.chat_send_player(user:get_player_name(), "Gate configuration was successfully written to FPGA!")
|
||||
|
||||
return itemstack
|
||||
end
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_fpga:programmer",
|
||||
recipe = {
|
||||
{'group:mesecon_conductor_craftable'},
|
||||
{'mesecons_materials:silicon'},
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
end
|
||||
|
||||
@ -1,67 +0,0 @@
|
||||
--Aliases
|
||||
|
||||
minetest.register_alias("mesecons_gamecompat:chest", "default:chest")
|
||||
minetest.register_alias("mesecons_gamecompat:chest_locked", "default:chest_locked")
|
||||
minetest.register_alias("mesecons_gamecompat:coalblock", "default:coalblock")
|
||||
minetest.register_alias("mesecons_gamecompat:cobble", "default:cobble")
|
||||
minetest.register_alias("mesecons_gamecompat:glass", "default:glass")
|
||||
minetest.register_alias("mesecons_gamecompat:lava_source", "default:lava_source")
|
||||
minetest.register_alias("mesecons_gamecompat:mese", "default:mese")
|
||||
minetest.register_alias("mesecons_gamecompat:mese_crystal", "default:mese_crystal")
|
||||
minetest.register_alias("mesecons_gamecompat:mese_crystal_fragment", "default:mese_crystal_fragment")
|
||||
minetest.register_alias("mesecons_gamecompat:obsidian_glass", "default:obsidian_glass")
|
||||
minetest.register_alias("mesecons_gamecompat:stone", "default:stone")
|
||||
minetest.register_alias("mesecons_gamecompat:steel_ingot", "default:steel_ingot")
|
||||
minetest.register_alias("mesecons_gamecompat:steelblock", "default:steelblock")
|
||||
minetest.register_alias("mesecons_gamecompat:torch", "default:torch")
|
||||
|
||||
if minetest.get_modpath("dye") then
|
||||
for _, color in ipairs(mesecon.dye_colors) do
|
||||
minetest.register_alias("mesecons_gamecompat:dye_" .. color, "dye:" .. color)
|
||||
end
|
||||
end
|
||||
|
||||
-- Sounds
|
||||
|
||||
mesecon.node_sound.default = default.node_sound_defaults()
|
||||
mesecon.node_sound.glass = default.node_sound_glass_defaults()
|
||||
mesecon.node_sound.leaves = default.node_sound_leaves_defaults()
|
||||
mesecon.node_sound.stone = default.node_sound_stone_defaults()
|
||||
mesecon.node_sound.wood = default.node_sound_wood_defaults()
|
||||
|
||||
if minetest.get_modpath("fire") then
|
||||
mesecon.sound_name.fire = "fire_fire"
|
||||
end
|
||||
|
||||
if minetest.get_modpath("tnt") then
|
||||
mesecon.sound_name.explode = "tnt_explode"
|
||||
end
|
||||
|
||||
-- MVPS stoppers
|
||||
|
||||
if minetest.get_modpath("mesecons_mvps") then
|
||||
-- All of the locked and internal nodes in Minetest Game
|
||||
for _, name in ipairs({
|
||||
"default:chest_locked",
|
||||
"default:chest_locked_open",
|
||||
"doors:door_steel_b_1", -- old style doors
|
||||
"doors:door_steel_b_2", --
|
||||
"doors:door_steel_t_1", --
|
||||
"doors:door_steel_t_2", --
|
||||
"doors:door_steel_a", -- new style doors
|
||||
"doors:door_steel_b", --
|
||||
"doors:door_steel_c", --
|
||||
"doors:door_steel_d", --
|
||||
"doors:hidden",
|
||||
"doors:trapdoor_steel",
|
||||
"doors:trapdoor_steel_open",
|
||||
"xpanes:door_steel_bar_a",
|
||||
"xpanes:door_steel_bar_b",
|
||||
"xpanes:door_steel_bar_c",
|
||||
"xpanes:door_steel_bar_d",
|
||||
"xpanes:trapdoor_steel_bar",
|
||||
"xpanes:trapdoor_steel_bar_open",
|
||||
}) do
|
||||
mesecon.register_mvps_stopper(name)
|
||||
end
|
||||
end
|
||||
@ -1,15 +0,0 @@
|
||||
mesecon.node_sound = {}
|
||||
|
||||
mesecon.sound_name = {}
|
||||
|
||||
mesecon.texture = {}
|
||||
|
||||
mesecon.dye_colors = {
|
||||
"red", "green", "blue", "grey", "dark_grey", "yellow",
|
||||
"orange", "white", "pink", "magenta", "cyan", "violet",
|
||||
}
|
||||
|
||||
if minetest.get_modpath("default") then
|
||||
minetest.log("info", "Mesecons: detected Minetest Game for game compatibility")
|
||||
dofile(minetest.get_modpath("mesecons_gamecompat").."/compat_mtg.lua")
|
||||
end
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_gamecompat
|
||||
depends = mesecons,mesecons_mvps
|
||||
6
mesecons_gates/depends.txt
Normal file
6
mesecons_gates/depends.txt
Normal file
@ -0,0 +1,6 @@
|
||||
mesecons
|
||||
mesecons_microcontroller
|
||||
mesecons_delayer
|
||||
|
||||
mesecons_torch
|
||||
mesecons_materials
|
||||
@ -1,24 +1,27 @@
|
||||
local selection_box = {
|
||||
type = "fixed",
|
||||
fixed = { -8/16, -8/16, -8/16, 8/16, -6/16, 8/16 }
|
||||
}
|
||||
|
||||
local nodebox = {
|
||||
type = "fixed",
|
||||
fixed = {
|
||||
{ -8/16, -8/16, -8/16, 8/16, -7/16, 8/16 }, -- bottom slab
|
||||
{ -6/16, -7/16, -6/16, 6/16, -6/16, 6/16 }
|
||||
},
|
||||
fixed = {{-8/16, -8/16, -8/16, 8/16, -7/16, 8/16 }},
|
||||
}
|
||||
|
||||
local gate_get_output_rules = mesecon.horiz_rules_getter({{x = 1, y = 0, z = 0}})
|
||||
local function gate_rotate_rules(node, rules)
|
||||
for rotations = 0, node.param2 - 1 do
|
||||
rules = mesecon.rotate_rules_left(rules)
|
||||
end
|
||||
return rules
|
||||
end
|
||||
|
||||
local gate_get_input_rules_oneinput = mesecon.horiz_rules_getter({{x =-1, y = 0, z = 0}})
|
||||
local function gate_get_output_rules(node)
|
||||
return gate_rotate_rules(node, {{x=1, y=0, z=0}})
|
||||
end
|
||||
|
||||
local gate_get_input_rules_twoinputs = mesecon.horiz_rules_getter({
|
||||
{x = 0, y = 0, z = 1, name = "input1"},
|
||||
{x = 0, y = 0, z = -1, name = "input2"},
|
||||
})
|
||||
local function gate_get_input_rules_oneinput(node)
|
||||
return gate_rotate_rules(node, {{x=-1, y=0, z=0}})
|
||||
end
|
||||
|
||||
local function gate_get_input_rules_twoinputs(node)
|
||||
return gate_rotate_rules(node, {{x=0, y=0, z=1, name="input1"},
|
||||
{x=0, y=0, z=-1, name="input2"}})
|
||||
end
|
||||
|
||||
local function set_gate(pos, node, state)
|
||||
local gate = minetest.registered_nodes[node.name]
|
||||
@ -54,6 +57,7 @@ end
|
||||
local function register_gate(name, inputnumber, assess, recipe, description)
|
||||
local get_inputrules = inputnumber == 2 and gate_get_input_rules_twoinputs or
|
||||
gate_get_input_rules_oneinput
|
||||
description = "Logic Gate: "..name
|
||||
|
||||
local basename = "mesecons_gates:"..name
|
||||
mesecon.register_node(basename, {
|
||||
@ -64,27 +68,18 @@ local function register_gate(name, inputnumber, assess, recipe, description)
|
||||
is_ground_content = false,
|
||||
drawtype = "nodebox",
|
||||
drop = basename.."_off",
|
||||
selection_box = selection_box,
|
||||
selection_box = nodebox,
|
||||
node_box = nodebox,
|
||||
walkable = true,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
assess = assess,
|
||||
onstate = basename.."_on",
|
||||
offstate = basename.."_off",
|
||||
inputnumber = inputnumber,
|
||||
after_dig_node = mesecon.do_cooldown,
|
||||
on_rotate = mesecon.on_rotate_horiz,
|
||||
},{
|
||||
tiles = {
|
||||
"jeija_microcontroller_bottom.png^".."jeija_gate_off.png^"..
|
||||
"jeija_gate_output_off.png^".."jeija_gate_"..name..".png",
|
||||
"jeija_microcontroller_bottom.png^".."jeija_gate_output_off.png^"..
|
||||
"[transformFY",
|
||||
"jeija_gate_side.png^".."jeija_gate_side_output_off.png",
|
||||
"jeija_gate_side.png",
|
||||
"jeija_gate_side.png",
|
||||
"jeija_gate_side.png"
|
||||
},
|
||||
tiles = {"jeija_microcontroller_bottom.png^".."jeija_gate_off.png^"..
|
||||
"jeija_gate_"..name..".png"},
|
||||
groups = {dig_immediate = 2, overheat = 1},
|
||||
mesecons = { receptor = {
|
||||
state = "off",
|
||||
@ -94,16 +89,8 @@ local function register_gate(name, inputnumber, assess, recipe, description)
|
||||
action_change = update_gate
|
||||
}}
|
||||
},{
|
||||
tiles = {
|
||||
"jeija_microcontroller_bottom.png^".."jeija_gate_on.png^"..
|
||||
"jeija_gate_output_on.png^".."jeija_gate_"..name..".png",
|
||||
"jeija_microcontroller_bottom.png^".."jeija_gate_output_on.png^"..
|
||||
"[transformFY",
|
||||
"jeija_gate_side.png^".."jeija_gate_side_output_on.png",
|
||||
"jeija_gate_side.png",
|
||||
"jeija_gate_side.png",
|
||||
"jeija_gate_side.png"
|
||||
},
|
||||
tiles = {"jeija_microcontroller_bottom.png^".."jeija_gate_on.png^"..
|
||||
"jeija_gate_"..name..".png"},
|
||||
groups = {dig_immediate = 2, not_in_creative_inventory = 1, overheat = 1},
|
||||
mesecons = { receptor = {
|
||||
state = "on",
|
||||
@ -113,6 +100,8 @@ local function register_gate(name, inputnumber, assess, recipe, description)
|
||||
action_change = update_gate
|
||||
}}
|
||||
})
|
||||
|
||||
minetest.register_craft({output = basename.."_off", recipe = recipe})
|
||||
end
|
||||
|
||||
register_gate("diode", 1, function (input) return input end,
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_gates
|
||||
depends = mesecons, mesecons_gamecompat, mesecons_microcontroller, mesecons_delayer, mesecons_torch, mesecons_materials
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 98 B |
Binary file not shown.
|
Before Width: | Height: | Size: 99 B |
Binary file not shown.
|
Before Width: | Height: | Size: 136 B |
Binary file not shown.
|
Before Width: | Height: | Size: 109 B |
Binary file not shown.
|
Before Width: | Height: | Size: 110 B |
1
mesecons_hydroturbine/depends.txt
Normal file
1
mesecons_hydroturbine/depends.txt
Normal file
@ -0,0 +1 @@
|
||||
mesecons
|
||||
@ -12,7 +12,6 @@ minetest.register_node("mesecons_hydroturbine:hydro_turbine_off", {
|
||||
"jeija_hydro_turbine_turbine_top_bottom_off.png",
|
||||
"jeija_hydro_turbine_turbine_misc_off.png"
|
||||
},
|
||||
use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "opaque" or nil,
|
||||
inventory_image = "jeija_hydro_turbine_inv.png",
|
||||
is_ground_content = false,
|
||||
wield_scale = {x=0.75, y=0.75, z=0.75},
|
||||
@ -23,7 +22,7 @@ minetest.register_node("mesecons_hydroturbine:hydro_turbine_off", {
|
||||
type = "fixed",
|
||||
fixed = { -0.5, -0.5, -0.5, 0.5, 1.5, 0.5 },
|
||||
},
|
||||
sounds = mesecon.node_sound.metal,
|
||||
sounds = default.node_sound_metal_defaults(),
|
||||
mesecons = {receptor = {
|
||||
state = mesecon.state.off
|
||||
}},
|
||||
@ -43,7 +42,6 @@ minetest.register_node("mesecons_hydroturbine:hydro_turbine_on", {
|
||||
{ name = "jeija_hydro_turbine_turbine_misc_on.png",
|
||||
animation = {type = "vertical_frames", aspect_w = 256, aspect_h = 32, length = 0.4} }
|
||||
},
|
||||
use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "clip" or nil,
|
||||
inventory_image = "jeija_hydro_turbine_inv.png",
|
||||
drop = "mesecons_hydroturbine:hydro_turbine_off 1",
|
||||
groups = {dig_immediate=2,not_in_creative_inventory=1},
|
||||
@ -53,7 +51,7 @@ minetest.register_node("mesecons_hydroturbine:hydro_turbine_on", {
|
||||
type = "fixed",
|
||||
fixed = { -0.5, -0.5, -0.5, 0.5, 1.5, 0.5 },
|
||||
},
|
||||
sounds = mesecon.node_sound.metal,
|
||||
sounds = default.node_sound_metal_defaults(),
|
||||
mesecons = {receptor = {
|
||||
state = mesecon.state.on
|
||||
}},
|
||||
@ -64,15 +62,15 @@ minetest.register_node("mesecons_hydroturbine:hydro_turbine_on", {
|
||||
local function is_flowing_water(pos)
|
||||
local name = minetest.get_node(pos).name
|
||||
local is_water = minetest.get_item_group(name, "water") > 0
|
||||
local def = minetest.registered_items[name]
|
||||
return is_water and (def and def.liquidtype == "flowing")
|
||||
local is_flowing = minetest.registered_items[name].liquidtype == "flowing"
|
||||
return (is_water and is_flowing)
|
||||
end
|
||||
|
||||
minetest.register_abm({
|
||||
nodenames = {"mesecons_hydroturbine:hydro_turbine_off"},
|
||||
interval = 1,
|
||||
chance = 1,
|
||||
action = function(pos)
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
local waterpos={x=pos.x, y=pos.y+1, z=pos.z}
|
||||
if is_flowing_water(waterpos) then
|
||||
minetest.set_node(pos, {name="mesecons_hydroturbine:hydro_turbine_on"})
|
||||
@ -85,7 +83,7 @@ minetest.register_abm({
|
||||
nodenames = {"mesecons_hydroturbine:hydro_turbine_on"},
|
||||
interval = 1,
|
||||
chance = 1,
|
||||
action = function(pos)
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
local waterpos={x=pos.x, y=pos.y+1, z=pos.z}
|
||||
if not is_flowing_water(waterpos) then
|
||||
minetest.set_node(pos, {name="mesecons_hydroturbine:hydro_turbine_off"})
|
||||
@ -94,3 +92,12 @@ nodenames = {"mesecons_hydroturbine:hydro_turbine_on"},
|
||||
end,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_hydroturbine:hydro_turbine_off 2",
|
||||
recipe = {
|
||||
{"","default:stick", ""},
|
||||
{"default:stick", "default:steel_ingot", "default:stick"},
|
||||
{"","default:stick", ""},
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_hydroturbine
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
2
mesecons_insulated/depends.txt
Normal file
2
mesecons_insulated/depends.txt
Normal file
@ -0,0 +1,2 @@
|
||||
mesecons
|
||||
screwdriver?
|
||||
@ -1,7 +1,13 @@
|
||||
local insulated_wire_get_rules = mesecon.horiz_rules_getter({
|
||||
{x = 1, y = 0, z = 0},
|
||||
{x = -1, y = 0, z = 0},
|
||||
})
|
||||
local screwdriver_exists = minetest.global_exists("screwdriver")
|
||||
|
||||
local function insulated_wire_get_rules(node)
|
||||
local rules = {{x = 1, y = 0, z = 0},
|
||||
{x =-1, y = 0, z = 0}}
|
||||
if node.param2 == 1 or node.param2 == 3 then
|
||||
return mesecon.rotate_rules_right(rules)
|
||||
end
|
||||
return rules
|
||||
end
|
||||
|
||||
minetest.register_node("mesecons_insulated:insulated_on", {
|
||||
drawtype = "nodebox",
|
||||
@ -30,14 +36,14 @@ minetest.register_node("mesecons_insulated:insulated_on", {
|
||||
},
|
||||
groups = {dig_immediate = 3, not_in_creative_inventory = 1},
|
||||
drop = "mesecons_insulated:insulated_off",
|
||||
sounds = mesecon.node_sound.default,
|
||||
sounds = default.node_sound_defaults(),
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.on,
|
||||
offstate = "mesecons_insulated:insulated_off",
|
||||
rules = insulated_wire_get_rules
|
||||
}},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
on_rotate = mesecon.on_rotate_horiz,
|
||||
on_rotate = screwdriver_exists and screwdriver.rotate_simple,
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_insulated:insulated_off", {
|
||||
@ -66,13 +72,21 @@ minetest.register_node("mesecons_insulated:insulated_off", {
|
||||
fixed = { -16/32-0.001, -17/32, -3/32, 16/32+0.001, -13/32, 3/32 }
|
||||
},
|
||||
groups = {dig_immediate = 3},
|
||||
sounds = mesecon.node_sound.default,
|
||||
sounds = default.node_sound_defaults(),
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.off,
|
||||
onstate = "mesecons_insulated:insulated_on",
|
||||
rules = insulated_wire_get_rules
|
||||
}},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
on_rotate = mesecon.on_rotate_horiz,
|
||||
on_rotate = screwdriver_exists and screwdriver.rotate_simple,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_insulated:insulated_off 3",
|
||||
recipe = {
|
||||
{"mesecons_materials:fiber", "mesecons_materials:fiber", "mesecons_materials:fiber"},
|
||||
{"mesecons:wire_00000000_off", "mesecons:wire_00000000_off", "mesecons:wire_00000000_off"},
|
||||
{"mesecons_materials:fiber", "mesecons_materials:fiber", "mesecons_materials:fiber"},
|
||||
}
|
||||
})
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_insulated
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 136 B |
Binary file not shown.
|
After Width: | Height: | Size: 136 B |
1
mesecons_lamp/depends.txt
Normal file
1
mesecons_lamp/depends.txt
Normal file
@ -0,0 +1 @@
|
||||
mesecons
|
||||
@ -9,12 +9,9 @@ local mesecon_lamp_box = {
|
||||
wall_side = {-0.375,-0.3125,-0.3125,-0.5,0.3125,0.3125},
|
||||
}
|
||||
|
||||
local use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "opaque" or nil
|
||||
|
||||
minetest.register_node("mesecons_lamp:lamp_on", {
|
||||
drawtype = "nodebox",
|
||||
tiles = {"jeija_meselamp_on.png"},
|
||||
use_texture_alpha = use_texture_alpha,
|
||||
paramtype = "light",
|
||||
paramtype2 = "wallmounted",
|
||||
is_ground_content = false,
|
||||
@ -26,7 +23,7 @@ minetest.register_node("mesecons_lamp:lamp_on", {
|
||||
selection_box = mesecon_lamp_box,
|
||||
groups = {dig_immediate = 3,not_in_creative_inventory = 1, mesecon_effector_on = 1},
|
||||
drop = "mesecons_lamp:lamp_off 1",
|
||||
sounds = mesecon.node_sound.glass,
|
||||
sounds = default.node_sound_glass_defaults(),
|
||||
mesecons = {effector = {
|
||||
action_off = function (pos, node)
|
||||
minetest.swap_node(pos, {name = "mesecons_lamp:lamp_off", param2 = node.param2})
|
||||
@ -39,7 +36,6 @@ minetest.register_node("mesecons_lamp:lamp_on", {
|
||||
minetest.register_node("mesecons_lamp:lamp_off", {
|
||||
drawtype = "nodebox",
|
||||
tiles = {"jeija_meselamp_off.png"},
|
||||
use_texture_alpha = use_texture_alpha,
|
||||
inventory_image = "jeija_meselamp.png",
|
||||
wield_image = "jeija_meselamp.png",
|
||||
paramtype = "light",
|
||||
@ -51,7 +47,7 @@ minetest.register_node("mesecons_lamp:lamp_off", {
|
||||
selection_box = mesecon_lamp_box,
|
||||
groups = {dig_immediate=3, mesecon_receptor_off = 1, mesecon_effector_off = 1},
|
||||
description = "Mesecon Lamp",
|
||||
sounds = mesecon.node_sound.glass,
|
||||
sounds = default.node_sound_glass_defaults(),
|
||||
mesecons = {effector = {
|
||||
action_on = function (pos, node)
|
||||
minetest.swap_node(pos, {name = "mesecons_lamp:lamp_on", param2 = node.param2})
|
||||
@ -60,3 +56,12 @@ minetest.register_node("mesecons_lamp:lamp_off", {
|
||||
}},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_lamp:lamp_off 1",
|
||||
recipe = {
|
||||
{"", "default:glass", ""},
|
||||
{"group:mesecon_conductor_craftable", "default:steel_ingot", "group:mesecon_conductor_craftable"},
|
||||
{"", "default:glass", ""},
|
||||
}
|
||||
})
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_lamp
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
2
mesecons_lightstone/depends.txt
Normal file
2
mesecons_lightstone/depends.txt
Normal file
@ -0,0 +1,2 @@
|
||||
mesecons
|
||||
dye
|
||||
@ -23,7 +23,7 @@ function mesecon.lightstone_add(name, base_item, texture_off, texture_on, desc)
|
||||
is_ground_content = false,
|
||||
groups = {cracky = 2, mesecon_effector_off = 1, mesecon = 2},
|
||||
description = desc,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {effector = {
|
||||
rules = lightstone_rules,
|
||||
action_on = function (pos, node)
|
||||
@ -38,7 +38,7 @@ function mesecon.lightstone_add(name, base_item, texture_off, texture_on, desc)
|
||||
groups = {cracky = 2, not_in_creative_inventory = 1, mesecon = 2},
|
||||
drop = "mesecons_lightstone:lightstone_" .. name .. "_off",
|
||||
light_source = minetest.LIGHT_MAX - 2,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {effector = {
|
||||
rules = lightstone_rules,
|
||||
action_off = function (pos, node)
|
||||
@ -48,18 +48,26 @@ function mesecon.lightstone_add(name, base_item, texture_off, texture_on, desc)
|
||||
on_blast = mesecon.on_blastnode,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_lightstone:lightstone_" .. name .. "_off",
|
||||
recipe = {
|
||||
{"",base_item,""},
|
||||
{base_item,"default:torch",base_item},
|
||||
{"","group:mesecon_conductor_craftable",""}
|
||||
}
|
||||
})
|
||||
end
|
||||
|
||||
|
||||
mesecon.lightstone_add("red", "mesecons_gamecompat:dye_red", "jeija_lightstone_red_off.png", "jeija_lightstone_red_on.png", "Red Lightstone")
|
||||
mesecon.lightstone_add("green", "mesecons_gamecompat:dye_green", "jeija_lightstone_green_off.png", "jeija_lightstone_green_on.png", "Green Lightstone")
|
||||
mesecon.lightstone_add("blue", "mesecons_gamecompat:dye_blue", "jeija_lightstone_blue_off.png", "jeija_lightstone_blue_on.png", "Blue Lightstone")
|
||||
mesecon.lightstone_add("gray", "mesecons_gamecompat:dye_grey", "jeija_lightstone_gray_off.png", "jeija_lightstone_gray_on.png", "Grey Lightstone")
|
||||
mesecon.lightstone_add("darkgray", "mesecons_gamecompat:dye_dark_grey", "jeija_lightstone_darkgray_off.png", "jeija_lightstone_darkgray_on.png", "Dark Grey Lightstone")
|
||||
mesecon.lightstone_add("yellow", "mesecons_gamecompat:dye_yellow", "jeija_lightstone_yellow_off.png", "jeija_lightstone_yellow_on.png", "Yellow Lightstone")
|
||||
mesecon.lightstone_add("orange", "mesecons_gamecompat:dye_orange", "jeija_lightstone_orange_off.png", "jeija_lightstone_orange_on.png", "Orange Lightstone")
|
||||
mesecon.lightstone_add("white", "mesecons_gamecompat:dye_white", "jeija_lightstone_white_off.png", "jeija_lightstone_white_on.png", "White Lightstone")
|
||||
mesecon.lightstone_add("pink", "mesecons_gamecompat:dye_pink", "jeija_lightstone_pink_off.png", "jeija_lightstone_pink_on.png", "Pink Lightstone")
|
||||
mesecon.lightstone_add("magenta", "mesecons_gamecompat:dye_magenta", "jeija_lightstone_magenta_off.png", "jeija_lightstone_magenta_on.png", "Magenta Lightstone")
|
||||
mesecon.lightstone_add("cyan", "mesecons_gamecompat:dye_cyan", "jeija_lightstone_cyan_off.png", "jeija_lightstone_cyan_on.png", "Cyan Lightstone")
|
||||
mesecon.lightstone_add("violet", "mesecons_gamecompat:dye_violet", "jeija_lightstone_violet_off.png", "jeija_lightstone_violet_on.png", "Violet Lightstone")
|
||||
mesecon.lightstone_add("red", "dye:red", "jeija_lightstone_red_off.png", "jeija_lightstone_red_on.png", "Red Lightstone")
|
||||
mesecon.lightstone_add("green", "dye:green", "jeija_lightstone_green_off.png", "jeija_lightstone_green_on.png", "Green Lightstone")
|
||||
mesecon.lightstone_add("blue", "dye:blue", "jeija_lightstone_blue_off.png", "jeija_lightstone_blue_on.png", "Blue Lightstone")
|
||||
mesecon.lightstone_add("gray", "dye:grey", "jeija_lightstone_gray_off.png", "jeija_lightstone_gray_on.png", "Grey Lightstone")
|
||||
mesecon.lightstone_add("darkgray", "dye:dark_grey", "jeija_lightstone_darkgray_off.png", "jeija_lightstone_darkgray_on.png", "Dark Grey Lightstone")
|
||||
mesecon.lightstone_add("yellow", "dye:yellow", "jeija_lightstone_yellow_off.png", "jeija_lightstone_yellow_on.png", "Yellow Lightstone")
|
||||
mesecon.lightstone_add("orange", "dye:orange", "jeija_lightstone_orange_off.png", "jeija_lightstone_orange_on.png", "Orange Lightstone")
|
||||
mesecon.lightstone_add("white", "dye:white", "jeija_lightstone_white_off.png", "jeija_lightstone_white_on.png", "White Lightstone")
|
||||
mesecon.lightstone_add("pink", "dye:pink", "jeija_lightstone_pink_off.png", "jeija_lightstone_pink_on.png", "Pink Lightstone")
|
||||
mesecon.lightstone_add("magenta", "dye:magenta", "jeija_lightstone_magenta_off.png", "jeija_lightstone_magenta_on.png", "Magenta Lightstone")
|
||||
mesecon.lightstone_add("cyan", "dye:cyan", "jeija_lightstone_cyan_off.png", "jeija_lightstone_cyan_on.png", "Cyan Lightstone")
|
||||
mesecon.lightstone_add("violet", "dye:violet", "jeija_lightstone_violet_off.png", "jeija_lightstone_violet_on.png", "Violet Lightstone")
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_lightstone
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
1
mesecons_luacontroller/depends.txt
Normal file
1
mesecons_luacontroller/depends.txt
Normal file
@ -0,0 +1 @@
|
||||
mesecons
|
||||
@ -43,16 +43,13 @@ local rules = {
|
||||
------------------
|
||||
-- These helpers are required to set the port states of the luacontroller
|
||||
|
||||
-- Updates the real port states according to the signal change.
|
||||
-- Returns whether the real port states actually changed.
|
||||
local function update_real_port_states(pos, rule_name, new_state)
|
||||
local meta = minetest.get_meta(pos)
|
||||
if rule_name == nil then
|
||||
meta:set_int("real_portstates", 1)
|
||||
return true
|
||||
return
|
||||
end
|
||||
local real_portstates = meta:get_int("real_portstates")
|
||||
local n = real_portstates - 1
|
||||
local n = meta:get_int("real_portstates") - 1
|
||||
local L = {}
|
||||
for i = 1, 4 do
|
||||
L[i] = n % 2
|
||||
@ -63,18 +60,18 @@ local function update_real_port_states(pos, rule_name, new_state)
|
||||
if rule_name.x == nil then
|
||||
for _, rname in ipairs(rule_name) do
|
||||
local port = pos_to_side[rname.x + (2 * rname.z) + 3]
|
||||
L[port] = (new_state == "on") and 1 or 0
|
||||
L[port] = (newstate == "on") and 1 or 0
|
||||
end
|
||||
else
|
||||
local port = pos_to_side[rule_name.x + (2 * rule_name.z) + 3]
|
||||
L[port] = (new_state == "on") and 1 or 0
|
||||
end
|
||||
local new_portstates = 1 + 1 * L[1] + 2 * L[2] + 4 * L[3] + 8 * L[4]
|
||||
if new_portstates ~= real_portstates then
|
||||
meta:set_int("real_portstates", new_portstates)
|
||||
return true
|
||||
end
|
||||
return false
|
||||
meta:set_int("real_portstates",
|
||||
1 +
|
||||
1 * L[1] +
|
||||
2 * L[2] +
|
||||
4 * L[3] +
|
||||
8 * L[4])
|
||||
end
|
||||
|
||||
|
||||
@ -175,7 +172,7 @@ local function burn_controller(pos)
|
||||
minetest.after(0.2, mesecon.receptor_off, pos, mesecon.rules.flat)
|
||||
end
|
||||
|
||||
local function overheat(pos)
|
||||
local function overheat(pos, meta)
|
||||
if mesecon.do_overheat(pos) then -- If too hot
|
||||
burn_controller(pos)
|
||||
return true
|
||||
@ -269,46 +266,6 @@ local function remove_functions(x)
|
||||
return x
|
||||
end
|
||||
|
||||
local function validate_iid(iid)
|
||||
if not iid then return true end -- nil is OK
|
||||
|
||||
local limit = mesecon.setting("luacontroller_interruptid_maxlen", 256)
|
||||
if type(iid) == "string" then
|
||||
if #iid <= limit then return true end -- string is OK unless too long
|
||||
return false, "An interrupt ID was too large!"
|
||||
end
|
||||
if type(iid) == "number" or type(iid) == "boolean" then return true, "Non-string interrupt IDs are deprecated" end
|
||||
|
||||
local warn
|
||||
local seen = {}
|
||||
local function check(t)
|
||||
if type(t) == "function" then
|
||||
warn = "Functions cannot be used in interrupt IDs"
|
||||
return false
|
||||
end
|
||||
if type(t) ~= "table" then
|
||||
return true
|
||||
end
|
||||
if seen[t] then
|
||||
warn = "Non-tree-like tables are forbidden as interrupt IDs"
|
||||
return false
|
||||
end
|
||||
seen[t] = true
|
||||
for k, v in pairs(t) do
|
||||
if not check(k) then return false end
|
||||
if not check(v) then return false end
|
||||
end
|
||||
return true
|
||||
end
|
||||
if not check(iid) then return false, warn end
|
||||
|
||||
if #minetest.serialize(iid) > limit then
|
||||
return false, "An interrupt ID was too large!"
|
||||
end
|
||||
|
||||
return true, "Table interrupt IDs are deprecated and are unreliable; use strings instead"
|
||||
end
|
||||
|
||||
-- The setting affects API so is not intended to be changeable at runtime
|
||||
local get_interrupt
|
||||
if mesecon.setting("luacontroller_lightweight_interrupts", false) then
|
||||
@ -325,18 +282,26 @@ else
|
||||
-- itbl: Flat table of functions to run after sandbox cleanup, used to prevent various security hazards
|
||||
get_interrupt = function(pos, itbl, send_warning)
|
||||
-- iid = interrupt id
|
||||
return function (time, iid)
|
||||
local function interrupt(time, iid)
|
||||
-- NOTE: This runs within string metatable sandbox, so don't *rely* on anything of the form (""):y
|
||||
-- Hence the values get moved out. Should take less time than original, so totally compatible
|
||||
if type(time) ~= "number" then error("Delay must be a number") end
|
||||
table.insert(itbl, function ()
|
||||
-- Outside string metatable sandbox, can safely run this now
|
||||
local luac_id = minetest.get_meta(pos):get_int("luac_id")
|
||||
local ok, warn = validate_iid(iid)
|
||||
if ok then mesecon.queue:add_action(pos, "lc_interrupt", {luac_id, iid}, time, iid, 1) end
|
||||
if warn then send_warning(warn) end
|
||||
-- Check if IID is dodgy, so you can't use interrupts to store an infinite amount of data.
|
||||
-- Note that this is safe from alter-after-free because this code gets run after the sandbox has ended.
|
||||
-- This runs outside of the timer and *shouldn't* harm perf. unless dodgy data is being sent in the first place
|
||||
iid = remove_functions(iid)
|
||||
local msg_ser = minetest.serialize(iid)
|
||||
if #msg_ser <= mesecon.setting("luacontroller_interruptid_maxlen", 256) then
|
||||
mesecon.queue:add_action(pos, "lc_interrupt", {luac_id, iid}, time, iid, 1)
|
||||
else
|
||||
send_warning("An interrupt ID was too large!")
|
||||
end
|
||||
end)
|
||||
end
|
||||
return interrupt
|
||||
end
|
||||
end
|
||||
|
||||
@ -470,12 +435,7 @@ local safe_globals = {
|
||||
|
||||
local function create_environment(pos, mem, event, itbl, send_warning)
|
||||
-- Gather variables for the environment
|
||||
local node_def = minetest.registered_nodes[minetest.get_node(pos).name]
|
||||
if not node_def then return end
|
||||
|
||||
local vports = node_def.virtual_portstates
|
||||
if not vports then return end
|
||||
|
||||
local vports = minetest.registered_nodes[minetest.get_node(pos).name].virtual_portstates
|
||||
local vports_copy = {}
|
||||
for k, v in pairs(vports) do vports_copy[k] = v end
|
||||
local rports = get_real_port_states(pos)
|
||||
@ -620,8 +580,9 @@ local function run_inner(pos, code, event)
|
||||
if overheat(pos) then return true, "" end
|
||||
if ignore_event(event, meta) then return true, "" end
|
||||
|
||||
-- Load mem from meta
|
||||
-- Load code & mem from meta
|
||||
local mem = load_memory(meta)
|
||||
local code = meta:get_string("code")
|
||||
|
||||
-- 'Last warning' label.
|
||||
local warning = ""
|
||||
@ -632,19 +593,16 @@ local function run_inner(pos, code, event)
|
||||
-- Create environment
|
||||
local itbl = {}
|
||||
local env = create_environment(pos, mem, event, itbl, send_warning)
|
||||
if not env then return false, "Env does not exist. Controller has been moved?" end
|
||||
|
||||
local success, msg
|
||||
-- Create the sandbox and execute code
|
||||
local f
|
||||
f, msg = create_sandbox(code, env)
|
||||
local f, msg = create_sandbox(code, env)
|
||||
if not f then return false, msg end
|
||||
-- Start string true sandboxing
|
||||
local onetruestring = getmetatable("")
|
||||
-- If a string sandbox is already up yet inconsistent, something is very wrong
|
||||
assert(onetruestring.__index == string)
|
||||
onetruestring.__index = env.string
|
||||
success, msg = pcall(f)
|
||||
local success, msg = pcall(f)
|
||||
onetruestring.__index = string
|
||||
-- End string true sandboxing
|
||||
if not success then return false, msg end
|
||||
@ -674,7 +632,6 @@ local function reset_formspec(meta, code, errmsg)
|
||||
code = minetest.formspec_escape(code or "")
|
||||
errmsg = minetest.formspec_escape(tostring(errmsg or ""))
|
||||
meta:set_string("formspec", "size[12,10]"
|
||||
.."style_type[label,textarea;font=mono]"
|
||||
.."background[-0.2,-0.25;12.4,10.75;jeija_luac_background.png]"
|
||||
.."label[0.1,8.3;"..errmsg.."]"
|
||||
.."textarea[0.2,0.2;12.2,9.5;code;;"..code.."]"
|
||||
@ -758,7 +715,7 @@ local selection_box = {
|
||||
local digiline = {
|
||||
receptor = {},
|
||||
effector = {
|
||||
action = function(pos, _, channel, msg)
|
||||
action = function(pos, node, channel, msg)
|
||||
msg = clean_and_weigh_digiline_message(msg)
|
||||
run(pos, {type = "digiline", channel = channel, msg = msg})
|
||||
end
|
||||
@ -776,7 +733,7 @@ local function set_program(pos, code)
|
||||
return run(pos, {type="program"})
|
||||
end
|
||||
|
||||
local function on_receive_fields(pos, _, fields, sender)
|
||||
local function on_receive_fields(pos, form_name, fields, sender)
|
||||
if not fields.program then
|
||||
return
|
||||
end
|
||||
@ -835,9 +792,8 @@ for d = 0, 1 do
|
||||
effector = {
|
||||
rules = input_rules[cid],
|
||||
action_change = function (pos, _, rule_name, new_state)
|
||||
if update_real_port_states(pos, rule_name, new_state) then
|
||||
run(pos, {type=new_state, pin=rule_name})
|
||||
end
|
||||
update_real_port_states(pos, rule_name, new_state)
|
||||
run(pos, {type=new_state, pin=rule_name})
|
||||
end,
|
||||
},
|
||||
receptor = {
|
||||
@ -871,7 +827,7 @@ for d = 0, 1 do
|
||||
node_box = node_box,
|
||||
on_construct = reset_meta,
|
||||
on_receive_fields = on_receive_fields,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = mesecons,
|
||||
digiline = digiline,
|
||||
-- Virtual portstates are the ports that
|
||||
@ -882,7 +838,7 @@ for d = 0, 1 do
|
||||
c = c == 1,
|
||||
d = d == 1,
|
||||
},
|
||||
after_dig_node = function (pos)
|
||||
after_dig_node = function (pos, node)
|
||||
mesecon.do_cooldown(pos)
|
||||
mesecon.receptor_off(pos, output_rules)
|
||||
end,
|
||||
@ -920,7 +876,7 @@ minetest.register_node(BASENAME .. "_burnt", {
|
||||
node_box = node_box,
|
||||
on_construct = reset_meta,
|
||||
on_receive_fields = on_receive_fields,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
virtual_portstates = {a = false, b = false, c = false, d = false},
|
||||
mesecons = {
|
||||
effector = {
|
||||
@ -931,4 +887,18 @@ minetest.register_node(BASENAME .. "_burnt", {
|
||||
},
|
||||
},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
})
|
||||
})
|
||||
|
||||
------------------------
|
||||
-- Craft Registration --
|
||||
------------------------
|
||||
|
||||
minetest.register_craft({
|
||||
output = BASENAME.."0000 2",
|
||||
recipe = {
|
||||
{'mesecons_materials:silicon', 'mesecons_materials:silicon', 'group:mesecon_conductor_craftable'},
|
||||
{'mesecons_materials:silicon', 'mesecons_materials:silicon', 'group:mesecon_conductor_craftable'},
|
||||
{'group:mesecon_conductor_craftable', 'group:mesecon_conductor_craftable', ''},
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_luacontroller
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
1
mesecons_materials/depends.txt
Normal file
1
mesecons_materials/depends.txt
Normal file
@ -0,0 +1 @@
|
||||
mesecons
|
||||
@ -2,17 +2,40 @@
|
||||
minetest.register_craftitem("mesecons_materials:glue", {
|
||||
image = "mesecons_glue.png",
|
||||
on_place_on_ground = minetest.craftitem_place_item,
|
||||
description="Glue",
|
||||
description="Glue",
|
||||
})
|
||||
|
||||
minetest.register_craftitem("mesecons_materials:fiber", {
|
||||
image = "mesecons_fiber.png",
|
||||
on_place_on_ground = minetest.craftitem_place_item,
|
||||
description="Fiber",
|
||||
description="Fiber",
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_materials:glue 2",
|
||||
type = "cooking",
|
||||
recipe = "group:sapling",
|
||||
cooktime = 2
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_materials:fiber 6",
|
||||
type = "cooking",
|
||||
recipe = "mesecons_materials:glue",
|
||||
cooktime = 4
|
||||
})
|
||||
|
||||
-- Silicon
|
||||
minetest.register_craftitem("mesecons_materials:silicon", {
|
||||
image = "mesecons_silicon.png",
|
||||
on_place_on_ground = minetest.craftitem_place_item,
|
||||
description="Silicon",
|
||||
})
|
||||
description="Silicon",
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_materials:silicon 4",
|
||||
recipe = {
|
||||
{"group:sand", "group:sand"},
|
||||
{"group:sand", "default:steel_ingot"},
|
||||
}
|
||||
})
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_materials
|
||||
depends = mesecons_gamecompat
|
||||
1
mesecons_microcontroller/depends.txt
Normal file
1
mesecons_microcontroller/depends.txt
Normal file
@ -0,0 +1 @@
|
||||
mesecons
|
||||
@ -44,9 +44,8 @@ local mesecons = {effector =
|
||||
{
|
||||
rules = input_rules,
|
||||
action_change = function (pos, node, rulename, newstate)
|
||||
if yc.update_real_portstates(pos, node, rulename, newstate) then
|
||||
yc.update(pos)
|
||||
end
|
||||
yc.update_real_portstates(pos, node, rulename, newstate)
|
||||
yc.update(pos)
|
||||
end
|
||||
}}
|
||||
if nodename ~= "mesecons_microcontroller:microcontroller0000" then
|
||||
@ -103,7 +102,7 @@ minetest.register_node(nodename, {
|
||||
for i=1, EEPROM_SIZE+1 do r=r.."0" end --Generate a string with EEPROM_SIZE*"0"
|
||||
meta:set_string("eeprom", r)
|
||||
end,
|
||||
on_receive_fields = function(pos, _, fields, sender)
|
||||
on_receive_fields = function(pos, formanme, fields, sender)
|
||||
local player_name = sender:get_player_name()
|
||||
if minetest.is_protected(pos, player_name) and
|
||||
not minetest.check_player_privs(player_name, {protection_bypass=true}) then
|
||||
@ -140,7 +139,7 @@ minetest.register_node(nodename, {
|
||||
yc.reset (pos)
|
||||
yc.update(pos)
|
||||
end,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = mesecons,
|
||||
after_dig_node = function (pos, node)
|
||||
rules = microc_rules[node.name]
|
||||
@ -153,6 +152,28 @@ end
|
||||
end
|
||||
end
|
||||
|
||||
if minetest.get_modpath("mesecons_luacontroller") then
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = "mesecons_microcontroller:microcontroller0000",
|
||||
recipe = {"mesecons_luacontroller:luacontroller0000"},
|
||||
})
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = "mesecons_luacontroller:luacontroller0000",
|
||||
recipe = {"mesecons_microcontroller:microcontroller0000"},
|
||||
})
|
||||
else
|
||||
minetest.register_craft({
|
||||
output = 'craft "mesecons_microcontroller:microcontroller0000" 2',
|
||||
recipe = {
|
||||
{'mesecons_materials:silicon', 'mesecons_materials:silicon', 'group:mesecon_conductor_craftable'},
|
||||
{'mesecons_materials:silicon', 'mesecons_materials:silicon', 'group:mesecon_conductor_craftable'},
|
||||
{'group:mesecon_conductor_craftable', 'group:mesecon_conductor_craftable', ''},
|
||||
}
|
||||
})
|
||||
end
|
||||
|
||||
yc.reset = function(pos)
|
||||
yc.action(pos, {a=false, b=false, c=false, d=false})
|
||||
local meta = minetest.get_meta(pos)
|
||||
@ -204,6 +225,7 @@ yc.parsecode = function(code, pos)
|
||||
local Lreal = yc.get_real_portstates(pos)
|
||||
local Lvirtual = yc.get_virtual_portstates(pos)
|
||||
if Lvirtual == nil then return nil end
|
||||
local c
|
||||
local eeprom = meta:get_string("eeprom")
|
||||
while true do
|
||||
local command, params
|
||||
@ -229,9 +251,9 @@ yc.parsecode = function(code, pos)
|
||||
if not params then return nil end
|
||||
end
|
||||
if command == "on" then
|
||||
Lvirtual = yc.command_on (params, Lvirtual)
|
||||
L = yc.command_on (params, Lvirtual)
|
||||
elseif command == "off" then
|
||||
Lvirtual = yc.command_off(params, Lvirtual)
|
||||
L = yc.command_off(params, Lvirtual)
|
||||
elseif command == "print" then
|
||||
local su = yc.command_print(params, eeprom, yc.merge_portstates(Lreal, Lvirtual))
|
||||
if su ~= true then return nil end
|
||||
@ -362,6 +384,7 @@ end
|
||||
|
||||
--Commands
|
||||
yc.command_on = function(params, L)
|
||||
local rules = {}
|
||||
for i, port in ipairs(params) do
|
||||
L = yc.set_portstate (port, true, L)
|
||||
end
|
||||
@ -369,6 +392,7 @@ yc.command_on = function(params, L)
|
||||
end
|
||||
|
||||
yc.command_off = function(params, L)
|
||||
local rules = {}
|
||||
for i, port in ipairs(params) do
|
||||
L = yc.set_portstate (port, false, L)
|
||||
end
|
||||
@ -381,7 +405,7 @@ yc.command_print = function(params, eeprom, L)
|
||||
if param:sub(1,1) == '"' and param:sub(#param, #param) == '"' then
|
||||
s = s..param:sub(2, #param-1)
|
||||
else
|
||||
local r = yc.command_parsecondition(param, L, eeprom)
|
||||
r = yc.command_parsecondition(param, L, eeprom)
|
||||
if r == "1" or r == "0" then
|
||||
s = s..r
|
||||
else return nil end
|
||||
@ -445,8 +469,8 @@ yc.command_after_execute = function(params)
|
||||
if yc.parsecode(params.code, params.pos) == nil then
|
||||
meta:set_string("infotext", "Code in after() not valid!")
|
||||
else
|
||||
if params.code ~= nil then
|
||||
meta:set_string("infotext", "Working Microcontroller\n"..params.code)
|
||||
if code ~= nil then
|
||||
meta:set_string("infotext", "Working Microcontroller\n"..code)
|
||||
else
|
||||
meta:set_string("infotext", "Working Microcontroller")
|
||||
end
|
||||
@ -519,8 +543,8 @@ yc.command_parsecondition = function(cond, L, eeprom)
|
||||
cond = string.gsub(cond, "!0", "1")
|
||||
cond = string.gsub(cond, "!1", "0")
|
||||
|
||||
i = 2
|
||||
l = string.len(cond)
|
||||
local i = 2
|
||||
local l = string.len(cond)
|
||||
while i<=l do
|
||||
local s = cond:sub(i,i)
|
||||
local b = tonumber(cond:sub(i-1, i-1))
|
||||
@ -529,7 +553,8 @@ yc.command_parsecondition = function(cond, L, eeprom)
|
||||
if s == "=" then
|
||||
if a==nil then return nil end
|
||||
if b==nil then return nil end
|
||||
local buf = a == b and "1" or "0"
|
||||
if a == b then buf = "1" end
|
||||
if a ~= b then buf = "0" end
|
||||
cond = string.gsub(cond, b..s..a, buf)
|
||||
i = 1
|
||||
l = string.len(cond)
|
||||
@ -537,8 +562,8 @@ yc.command_parsecondition = function(cond, L, eeprom)
|
||||
i = i + 1
|
||||
end
|
||||
|
||||
i = 2
|
||||
l = string.len(cond)
|
||||
local i = 2
|
||||
local l = string.len(cond)
|
||||
while i<=l do
|
||||
local s = cond:sub(i,i)
|
||||
local b = tonumber(cond:sub(i-1, i-1))
|
||||
@ -634,16 +659,13 @@ yc.set_portstate = function(port, state, L)
|
||||
return L
|
||||
end
|
||||
|
||||
-- Updates the real port states according to the signal change.
|
||||
-- Returns whether the real port states actually changed.
|
||||
yc.update_real_portstates = function(pos, _, rulename, newstate)
|
||||
yc.update_real_portstates = function(pos, node, rulename, newstate)
|
||||
local meta = minetest.get_meta(pos)
|
||||
if rulename == nil then
|
||||
meta:set_int("real_portstates", 1)
|
||||
return true
|
||||
return
|
||||
end
|
||||
local real_portstates = meta:get_int("real_portstates")
|
||||
local n = real_portstates - 1
|
||||
local n = meta:get_int("real_portstates") - 1
|
||||
local L = {}
|
||||
for i = 1, 4 do
|
||||
L[i] = n%2
|
||||
@ -658,12 +680,7 @@ yc.update_real_portstates = function(pos, _, rulename, newstate)
|
||||
local port = ({4, 1, nil, 3, 2})[rulename.x+2*rulename.z+3]
|
||||
L[port] = (newstate == "on") and 1 or 0
|
||||
end
|
||||
local new_portstates = 1 + L[1] + 2*L[2] + 4*L[3] + 8*L[4]
|
||||
if new_portstates ~= real_portstates then
|
||||
meta:set_int("real_portstates", new_portstates)
|
||||
return true
|
||||
end
|
||||
return false
|
||||
meta:set_int("real_portstates", 1 + L[1] + 2*L[2] + 4*L[3] + 8*L[4])
|
||||
end
|
||||
|
||||
yc.get_real_portstates = function(pos) -- determine if ports are powered (by itself or from outside)
|
||||
@ -679,7 +696,7 @@ end
|
||||
|
||||
yc.get_virtual_portstates = function(pos) -- portstates according to the name
|
||||
local name = minetest.get_node(pos).name
|
||||
local _, a = string.find(name, ":microcontroller")
|
||||
local b, a = string.find(name, ":microcontroller")
|
||||
if a == nil then return nil end
|
||||
a = a + 1
|
||||
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_microcontroller
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
3
mesecons_movestones/depends.txt
Normal file
3
mesecons_movestones/depends.txt
Normal file
@ -0,0 +1,3 @@
|
||||
mesecons
|
||||
mesecons_materials
|
||||
mesecons_mvps
|
||||
@ -66,12 +66,11 @@ function mesecon.register_movestone(name, def, is_sticky, is_vertical)
|
||||
mesecon.on_dignode(pos, node)
|
||||
mesecon.on_placenode(frontpos, node)
|
||||
minetest.get_node_timer(frontpos):start(timer_interval)
|
||||
minetest.sound_play("movestone", { pos = pos, max_hear_distance = 20, gain = 0.5 }, true)
|
||||
|
||||
-- ### Step 3: If sticky, pull stack behind ###
|
||||
if is_sticky then
|
||||
local backpos = vector.subtract(pos, direction)
|
||||
local success, _, oldstack = mesecon.mvps_pull_all(backpos, direction, max_pull, owner)
|
||||
success, stack, oldstack = mesecon.mvps_pull_all(backpos, direction, max_pull, owner)
|
||||
if success then
|
||||
mesecon.mvps_move_objects(backpos, vector.multiply(direction, -1), oldstack, -1)
|
||||
end
|
||||
@ -94,7 +93,7 @@ function mesecon.register_movestone(name, def, is_sticky, is_vertical)
|
||||
|
||||
def.after_place_node = mesecon.mvps_set_owner
|
||||
|
||||
def.on_punch = function(pos, _, player)
|
||||
def.on_punch = function(pos, node, player)
|
||||
local player_name = player and player.get_player_name and player:get_player_name()
|
||||
if mesecon.mvps_claim(pos, player_name) then
|
||||
minetest.get_node_timer(pos):start(timer_interval)
|
||||
@ -102,7 +101,7 @@ function mesecon.register_movestone(name, def, is_sticky, is_vertical)
|
||||
end
|
||||
end
|
||||
|
||||
def.on_timer = function(pos)
|
||||
def.on_timer = function(pos, elapsed)
|
||||
local sourcepos = mesecon.is_powered(pos)
|
||||
if not sourcepos then
|
||||
return
|
||||
@ -129,7 +128,7 @@ mesecon.register_movestone("mesecons_movestones:movestone", {
|
||||
},
|
||||
groups = {cracky = 3},
|
||||
description = "Movestone",
|
||||
sounds = mesecon.node_sound.stone
|
||||
sounds = default.node_sound_stone_defaults()
|
||||
}, false, false)
|
||||
|
||||
mesecon.register_movestone("mesecons_movestones:sticky_movestone", {
|
||||
@ -143,7 +142,7 @@ mesecon.register_movestone("mesecons_movestones:sticky_movestone", {
|
||||
},
|
||||
groups = {cracky = 3},
|
||||
description = "Sticky Movestone",
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
}, true, false)
|
||||
|
||||
mesecon.register_movestone("mesecons_movestones:movestone_vertical", {
|
||||
@ -157,7 +156,7 @@ mesecon.register_movestone("mesecons_movestones:movestone_vertical", {
|
||||
},
|
||||
groups = {cracky = 3},
|
||||
description = "Vertical Movestone",
|
||||
sounds = mesecon.node_sound.stone
|
||||
sounds = default.node_sound_stone_defaults()
|
||||
}, false, true)
|
||||
|
||||
mesecon.register_movestone("mesecons_movestones:sticky_movestone_vertical", {
|
||||
@ -171,10 +170,64 @@ mesecon.register_movestone("mesecons_movestones:sticky_movestone_vertical", {
|
||||
},
|
||||
groups = {cracky = 3},
|
||||
description = "Vertical Sticky Movestone",
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
}, true, true)
|
||||
|
||||
|
||||
-- crafting:
|
||||
-- base recipe:
|
||||
minetest.register_craft({
|
||||
output = "mesecons_movestones:movestone 2",
|
||||
recipe = {
|
||||
{"default:stone", "default:stone", "default:stone"},
|
||||
{"group:mesecon_conductor_craftable", "group:mesecon_conductor_craftable", "group:mesecon_conductor_craftable"},
|
||||
{"default:stone", "default:stone", "default:stone"},
|
||||
}
|
||||
})
|
||||
|
||||
-- conversation:
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = "mesecons_movestones:movestone",
|
||||
recipe = {"mesecons_movestones:movestone_vertical"},
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = "mesecons_movestones:movestone_vertical",
|
||||
recipe = {"mesecons_movestones:movestone"},
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = "mesecons_movestones:sticky_movestone",
|
||||
recipe = {"mesecons_movestones:sticky_movestone_vertical"},
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
type = "shapeless",
|
||||
output = "mesecons_movestones:sticky_movestone_vertical",
|
||||
recipe = {"mesecons_movestones:sticky_movestone"},
|
||||
})
|
||||
|
||||
-- make sticky:
|
||||
minetest.register_craft({
|
||||
output = "mesecons_movestones:sticky_movestone",
|
||||
recipe = {
|
||||
{"mesecons_materials:glue", "mesecons_movestones:movestone", "mesecons_materials:glue"},
|
||||
}
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_movestones:sticky_movestone_vertical",
|
||||
recipe = {
|
||||
{"mesecons_materials:glue"},
|
||||
{"mesecons_movestones:movestone_vertical"},
|
||||
{"mesecons_materials:glue"},
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
-- legacy code:
|
||||
minetest.register_alias("mesecons_movestones:movestone_active",
|
||||
"mesecons_movestones:movestone")
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_movestones
|
||||
depends = mesecons, mesecons_gamecompat, mesecons_materials, mesecons_mvps
|
||||
Binary file not shown.
1
mesecons_mvps/depends.txt
Normal file
1
mesecons_mvps/depends.txt
Normal file
@ -0,0 +1 @@
|
||||
mesecons
|
||||
@ -46,9 +46,11 @@ local function on_mvps_move(moved_nodes)
|
||||
end
|
||||
end
|
||||
|
||||
function mesecon.mvps_process_stack()
|
||||
-- This function is kept for compatibility.
|
||||
-- It used to call on_placenode on moved nodes, but that is now done automatically.
|
||||
function mesecon.mvps_process_stack(stack)
|
||||
-- update mesecons for placed nodes ( has to be done after all nodes have been added )
|
||||
for _, n in ipairs(stack) do
|
||||
mesecon.on_placenode(n.pos, minetest.get_node(n.pos))
|
||||
end
|
||||
end
|
||||
|
||||
-- tests if the node can be pushed into, e.g. air, water, grass
|
||||
@ -63,31 +65,28 @@ end
|
||||
function mesecon.mvps_get_stack(pos, dir, maximum, all_pull_sticky)
|
||||
-- determine the number of nodes to be pushed
|
||||
local nodes = {}
|
||||
local pos_set = {}
|
||||
local frontiers = mesecon.fifo_queue.new()
|
||||
frontiers:add(vector.new(pos))
|
||||
local frontiers = {pos}
|
||||
|
||||
for np in frontiers:iter() do
|
||||
local np_hash = minetest.hash_node_position(np)
|
||||
local nn = not pos_set[np_hash] and minetest.get_node(np)
|
||||
if nn and not node_replaceable(nn.name) then
|
||||
pos_set[np_hash] = true
|
||||
while #frontiers > 0 do
|
||||
local np = frontiers[1]
|
||||
local nn = minetest.get_node(np)
|
||||
|
||||
if not node_replaceable(nn.name) then
|
||||
table.insert(nodes, {node = nn, pos = np})
|
||||
if #nodes > maximum then return nil end
|
||||
|
||||
-- add connected nodes to frontiers
|
||||
-- add connected nodes to frontiers, connected is a vector list
|
||||
-- the vectors must be absolute positions
|
||||
local connected = {}
|
||||
if minetest.registered_nodes[nn.name]
|
||||
and minetest.registered_nodes[nn.name].mvps_sticky then
|
||||
local connected = minetest.registered_nodes[nn.name].mvps_sticky(np, nn)
|
||||
for _, cp in ipairs(connected) do
|
||||
frontiers:add(cp)
|
||||
end
|
||||
connected = minetest.registered_nodes[nn.name].mvps_sticky(np, nn)
|
||||
end
|
||||
|
||||
frontiers:add(vector.add(np, dir))
|
||||
table.insert(connected, vector.add(np, dir))
|
||||
|
||||
-- If adjacent node is sticky block and connects add that
|
||||
-- position
|
||||
-- position to the connected table
|
||||
for _, r in ipairs(mesecon.rules.alldirs) do
|
||||
local adjpos = vector.add(np, r)
|
||||
local adjnode = minetest.get_node(adjpos)
|
||||
@ -99,16 +98,36 @@ function mesecon.mvps_get_stack(pos, dir, maximum, all_pull_sticky)
|
||||
-- connects to this position?
|
||||
for _, link in ipairs(sticksto) do
|
||||
if vector.equals(link, np) then
|
||||
frontiers:add(adjpos)
|
||||
table.insert(connected, adjpos)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
if all_pull_sticky then
|
||||
frontiers:add(vector.subtract(np, dir))
|
||||
table.insert(connected, vector.subtract(np, dir))
|
||||
end
|
||||
|
||||
-- Make sure there are no duplicates in frontiers / nodes before
|
||||
-- adding nodes in "connected" to frontiers
|
||||
for _, cp in ipairs(connected) do
|
||||
local duplicate = false
|
||||
for _, rp in ipairs(nodes) do
|
||||
if vector.equals(cp, rp.pos) then
|
||||
duplicate = true
|
||||
end
|
||||
end
|
||||
for _, fp in ipairs(frontiers) do
|
||||
if vector.equals(cp, fp) then
|
||||
duplicate = true
|
||||
end
|
||||
end
|
||||
if not duplicate then
|
||||
table.insert(frontiers, cp)
|
||||
end
|
||||
end
|
||||
end
|
||||
table.remove(frontiers, 1)
|
||||
end
|
||||
|
||||
return nodes
|
||||
@ -144,7 +163,7 @@ local function add_pos(positions, pos)
|
||||
end
|
||||
|
||||
local function are_protected(positions, player_name)
|
||||
local mode = mesecon.setting("mvps_protection_mode", "compat")
|
||||
local mode = mesecon.setting("mvps_protection_mode", "normal")
|
||||
if mode == "ignore" then
|
||||
return false
|
||||
end
|
||||
@ -220,8 +239,6 @@ function mesecon.mvps_push_or_pull(pos, stackdir, movedir, maximum, all_pull_sti
|
||||
minetest.remove_node(n.pos)
|
||||
end
|
||||
|
||||
local oldstack = mesecon.tablecopy(nodes)
|
||||
|
||||
-- update mesecons for removed nodes ( has to be done after all nodes have been removed )
|
||||
for _, n in ipairs(nodes) do
|
||||
mesecon.on_dignode(n.pos, n.node)
|
||||
@ -231,12 +248,6 @@ function mesecon.mvps_push_or_pull(pos, stackdir, movedir, maximum, all_pull_sti
|
||||
for _, n in ipairs(nodes) do
|
||||
local np = vector.add(n.pos, movedir)
|
||||
|
||||
-- Turn off conductors in transit
|
||||
local conductor = mesecon.get_conductor(n.node.name)
|
||||
if conductor and conductor.state ~= mesecon.state.off then
|
||||
n.node.name = conductor.offstate or conductor.states[1]
|
||||
end
|
||||
|
||||
minetest.set_node(np, n.node)
|
||||
minetest.get_meta(np):from_table(n.meta)
|
||||
if n.node_timer then
|
||||
@ -245,6 +256,7 @@ function mesecon.mvps_push_or_pull(pos, stackdir, movedir, maximum, all_pull_sti
|
||||
end
|
||||
|
||||
local moved_nodes = {}
|
||||
local oldstack = mesecon.tablecopy(nodes)
|
||||
for i in ipairs(nodes) do
|
||||
moved_nodes[i] = {}
|
||||
moved_nodes[i].oldpos = nodes[i].pos
|
||||
@ -261,6 +273,7 @@ function mesecon.mvps_push_or_pull(pos, stackdir, movedir, maximum, all_pull_sti
|
||||
end
|
||||
|
||||
function mesecon.mvps_move_objects(pos, dir, nodestack, movefactor)
|
||||
local objects_to_move = {}
|
||||
local dir_k
|
||||
local dir_l
|
||||
for k, v in pairs(dir) do
|
||||
@ -272,7 +285,7 @@ function mesecon.mvps_move_objects(pos, dir, nodestack, movefactor)
|
||||
end
|
||||
movefactor = movefactor or 1
|
||||
dir = vector.multiply(dir, movefactor)
|
||||
for id, obj in pairs(minetest.get_objects_inside_radius(pos, #nodestack + 1)) do
|
||||
for id, obj in pairs(minetest.object_refs) do
|
||||
local obj_pos = obj:get_pos()
|
||||
local cbox = obj:get_properties().collisionbox
|
||||
local min_pos = vector.add(obj_pos, vector.new(cbox[1], cbox[2], cbox[3]))
|
||||
@ -318,6 +331,11 @@ end
|
||||
-- TODO: load blocks instead, as with wires.
|
||||
mesecon.register_mvps_stopper("ignore")
|
||||
|
||||
mesecon.register_mvps_stopper("doors:door_steel_b_1")
|
||||
mesecon.register_mvps_stopper("doors:door_steel_t_1")
|
||||
mesecon.register_mvps_stopper("doors:door_steel_b_2")
|
||||
mesecon.register_mvps_stopper("doors:door_steel_t_2")
|
||||
mesecon.register_mvps_stopper("default:chest_locked")
|
||||
mesecon.register_on_mvps_move(mesecon.move_hot_nodes)
|
||||
mesecon.register_on_mvps_move(function(moved_nodes)
|
||||
for i = 1, #moved_nodes do
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_mvps
|
||||
depends = mesecons
|
||||
1
mesecons_noteblock/depends.txt
Normal file
1
mesecons_noteblock/depends.txt
Normal file
@ -0,0 +1 @@
|
||||
mesecons
|
||||
@ -1,13 +1,12 @@
|
||||
This effector makes a sound if powered and can be used for making music. Normally it makes piano sounds. The sound frequency can be changed by punching the block (only works for piano). There are some special sounds that depend on the block below:
|
||||
This effector makes a sound if powered and can be used for making music. Normally it makes piano sounds. The sound frequency can be changed by punching the block. There are some special sounds that depend on the block below:
|
||||
<table colspace="5">
|
||||
<tr><th>Block Below</th><th>Effect</th></tr>
|
||||
<tr><td>Glass or Obsidian Glass</td><td>Hi-hat</td></tr>
|
||||
<tr><td>Any stone</td><td>Kick</td></tr>
|
||||
<tr><td>Chest or Locked Chest</td><td>Snare</td></tr>
|
||||
<tr><td>Any tree</td><td>Crash</td></tr>
|
||||
<tr><td>Any wooden planks</td><td>Lite Crash</td></tr>
|
||||
<tr><td>Coal Block</td><td>Explosion sound</td></tr>
|
||||
<tr><td>Lava Source</td><td>Fire sound</td></tr>
|
||||
<tr><td>Steel Block</td><td>Piano (high pitch, one octave higher than normal)</td></tr>
|
||||
<tr><td>Any other block</td><td>Piano (low pitch)</td></tr>
|
||||
<tr><td>Glass</td><td>Hihat</td></tr>
|
||||
<tr><td>Stone</td><td>Kick</td></tr>
|
||||
<tr><td>Chest</td><td>Snare</td></tr>
|
||||
<tr><td>Tree</td><td>Crash</td></tr>
|
||||
<tr><td>Wood</td><td>Lite Crash</td></tr>
|
||||
<tr><td>Coal Block</td><td>Explosion Sound </td></tr>
|
||||
<tr><td>Lava Source</td><td>Fire Sound</td></tr>
|
||||
<tr><td>Steel Block</td><td>Raises the pitch by one octave</td></tr>
|
||||
</table>
|
||||
|
||||
@ -3,16 +3,12 @@ minetest.register_node("mesecons_noteblock:noteblock", {
|
||||
tiles = {"mesecons_noteblock.png"},
|
||||
is_ground_content = false,
|
||||
groups = {snappy=2, choppy=2, oddly_breakable_by_hand=2},
|
||||
on_punch = function(pos, node, puncher) -- change sound when punched
|
||||
if minetest.is_protected(pos, puncher and puncher:get_player_name() or "") then
|
||||
return
|
||||
end
|
||||
|
||||
on_punch = function(pos, node) -- change sound when punched
|
||||
node.param2 = (node.param2+1)%12
|
||||
mesecon.noteblock_play(pos, node.param2)
|
||||
minetest.set_node(pos, node)
|
||||
end,
|
||||
sounds = mesecon.node_sound.wood,
|
||||
sounds = default.node_sound_wood_defaults(),
|
||||
mesecons = {effector = { -- play sound when activated
|
||||
action_on = function(pos, node)
|
||||
mesecon.noteblock_play(pos, node.param2)
|
||||
@ -21,6 +17,15 @@ minetest.register_node("mesecons_noteblock:noteblock", {
|
||||
on_blast = mesecon.on_blastnode,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_noteblock:noteblock 1",
|
||||
recipe = {
|
||||
{"group:wood", "group:wood", "group:wood"},
|
||||
{"group:mesecon_conductor_craftable", "default:steel_ingot", "group:mesecon_conductor_craftable"},
|
||||
{"group:wood", "group:wood", "group:wood"},
|
||||
}
|
||||
})
|
||||
|
||||
local soundnames = {
|
||||
[0] = "mesecons_noteblock_csharp",
|
||||
"mesecons_noteblock_d",
|
||||
@ -37,57 +42,30 @@ local soundnames = {
|
||||
"mesecons_noteblock_c"
|
||||
}
|
||||
|
||||
local node_sounds = {}
|
||||
for alias, sound in pairs({
|
||||
["mesecons_gamecompat:lava_source"] = mesecon.sound_name.fire,
|
||||
["mesecons_gamecompat:chest"] = "mesecons_noteblock_snare",
|
||||
["mesecons_gamecompat:chest_locked"] = "mesecons_noteblock_snare",
|
||||
["mesecons_gamecompat:coalblock"] = mesecon.sound_name.explode,
|
||||
["mesecons_gamecompat:glass"] = "mesecons_noteblock_hihat",
|
||||
["mesecons_gamecompat:obsidian_glass"] = "mesecons_noteblock_hihat",
|
||||
}) do
|
||||
local nodename = minetest.registered_aliases[alias]
|
||||
if nodename then
|
||||
node_sounds[nodename] = sound
|
||||
end
|
||||
end
|
||||
|
||||
local node_sounds_group = {
|
||||
["stone"] = "mesecons_noteblock_kick",
|
||||
["tree"] = "mesecons_noteblock_crash",
|
||||
["wood"] = "mesecons_noteblock_litecrash",
|
||||
local node_sounds = {
|
||||
["default:glass"] = "mesecons_noteblock_hihat",
|
||||
["default:stone"] = "mesecons_noteblock_kick",
|
||||
["default:lava_source"] = "fire_fire",
|
||||
["default:chest"] = "mesecons_noteblock_snare",
|
||||
["default:tree"] = "mesecons_noteblock_crash",
|
||||
["default:wood"] = "mesecons_noteblock_litecrash",
|
||||
["default:coalblock"] = "tnt_explode",
|
||||
}
|
||||
|
||||
local steelblock_nodename = minetest.registered_aliases["mesecons_gamecompat:steelblock"]
|
||||
mesecon.noteblock_play = function(pos, param2)
|
||||
pos.y = pos.y-1
|
||||
local nodeunder = minetest.get_node(pos).name
|
||||
local soundname = node_sounds[nodeunder]
|
||||
if not soundname then
|
||||
for k,v in pairs(node_sounds_group) do
|
||||
local g = minetest.get_item_group(nodeunder, k)
|
||||
if g ~= 0 then
|
||||
soundname = v
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
if not soundname then
|
||||
soundname = soundnames[param2]
|
||||
if not soundname then
|
||||
minetest.log("error", "[mesecons_noteblock] No soundname found, test param2")
|
||||
return
|
||||
end
|
||||
if nodeunder == steelblock_nodename then
|
||||
if nodeunder == "default:steelblock" then
|
||||
soundname = soundname.. 2
|
||||
end
|
||||
end
|
||||
pos.y = pos.y+1
|
||||
if soundname == "fire_fire" then
|
||||
-- Smoothly fade out fire sound
|
||||
local handle = minetest.sound_play(soundname, {pos = pos, loop = true})
|
||||
minetest.after(3.0, minetest.sound_fade, handle, -1.5, 0.0)
|
||||
else
|
||||
minetest.sound_play(soundname, {pos = pos}, true)
|
||||
end
|
||||
minetest.sound_play(soundname, {pos = pos})
|
||||
end
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_noteblock
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user