forked from minetest-mods/mesecons
Compare commits
4 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 966f9a56a6 | |||
| 30c28d882f | |||
| 78782c9b2b | |||
| 51cf528732 |
41
.github/workflows/check.yml
vendored
41
.github/workflows/check.yml
vendored
@ -1,41 +0,0 @@
|
||||
on: [push, pull_request]
|
||||
name: "Check"
|
||||
|
||||
jobs:
|
||||
lint:
|
||||
runs-on: ubuntu-latest
|
||||
name: "Luacheck"
|
||||
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 ./
|
||||
|
||||
mineunit:
|
||||
runs-on: ubuntu-latest
|
||||
name: "Mineunit tests"
|
||||
steps:
|
||||
- uses: actions/checkout@main
|
||||
- name: apt
|
||||
run: sudo apt-get install -y luarocks
|
||||
- name: busted install
|
||||
run: luarocks install --local busted
|
||||
- name: luacov install
|
||||
run: luarocks install --local luacov
|
||||
- name: mineunit install
|
||||
run: luarocks install --server=https://luarocks.org/dev --local mineunit
|
||||
- name: run mesecons tests
|
||||
working-directory: ./mesecons/
|
||||
run: $HOME/.luarocks/bin/mineunit -q
|
||||
- name: run mesecons_mvps tests
|
||||
working-directory: ./mesecons_mvps/
|
||||
run: $HOME/.luarocks/bin/mineunit -q
|
||||
- name: run mesecons_fpga tests
|
||||
working-directory: ./mesecons_fpga/
|
||||
run: $HOME/.luarocks/bin/mineunit -q
|
||||
- name: run mesecons_luacontroller tests
|
||||
working-directory: ./mesecons_luacontroller/
|
||||
run: $HOME/.luarocks/bin/mineunit -q
|
||||
26
.github/workflows/test.yml
vendored
26
.github/workflows/test.yml
vendored
@ -1,26 +0,0 @@
|
||||
on: [push, pull_request]
|
||||
name: "Test"
|
||||
|
||||
jobs:
|
||||
test:
|
||||
name: "Smoke Test ${{ matrix.cfg.image }}"
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 5
|
||||
strategy:
|
||||
matrix:
|
||||
cfg:
|
||||
- { image: 'registry.gitlab.com/minetest/minetest/server:5.0.1', mtg: false }
|
||||
- { image: 'ghcr.io/minetest/minetest:5.10.0', mtg: true }
|
||||
steps:
|
||||
- uses: actions/checkout@main
|
||||
|
||||
- uses: actions/checkout@main
|
||||
with:
|
||||
repository: 'minetest/minetest_game'
|
||||
path: ./.test/minetest_game
|
||||
if: ${{ matrix.cfg.mtg }}
|
||||
|
||||
- name: Run tests
|
||||
run: ./.test/run.sh
|
||||
env:
|
||||
DOCKER_IMAGE: "${{ matrix.cfg.image }}"
|
||||
2
.gitignore
vendored
2
.gitignore
vendored
@ -1,3 +1 @@
|
||||
*~
|
||||
*.patch
|
||||
*.diff
|
||||
|
||||
62
.luacheckrc
62
.luacheckrc
@ -1,62 +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 = {
|
||||
"core",
|
||||
"default",
|
||||
"digiline",
|
||||
"doors",
|
||||
"dump",
|
||||
"jit",
|
||||
"minetest",
|
||||
"screwdriver",
|
||||
"string.split",
|
||||
"table.copy",
|
||||
"table.insert_all",
|
||||
"vector",
|
||||
"VoxelArea",
|
||||
"mcl_dyes",
|
||||
"mcl_sounds",
|
||||
}
|
||||
|
||||
globals = {"mesecon"}
|
||||
|
||||
files["mesecons/actionqueue.lua"] = {
|
||||
globals = {"minetest.registered_globalsteps"},
|
||||
}
|
||||
|
||||
-- Test-specific stuff follows.
|
||||
|
||||
local test_conf = {
|
||||
read_globals = {
|
||||
"assert",
|
||||
"fixture",
|
||||
"mineunit",
|
||||
"Player",
|
||||
"sourcefile",
|
||||
"world",
|
||||
},
|
||||
}
|
||||
files["*/spec/*.lua"] = test_conf
|
||||
files[".test_fixtures/*.lua"] = test_conf
|
||||
|
||||
files[".test_fixtures/screwdriver.lua"] = {
|
||||
globals = {"screwdriver"},
|
||||
}
|
||||
|
||||
files[".test_fixtures/mesecons_fpga.lua"] = {
|
||||
globals = {"minetest.register_on_player_receive_fields"},
|
||||
}
|
||||
@ -1,3 +0,0 @@
|
||||
mg_name = singlenode
|
||||
mesecon.internal_test = true
|
||||
random_mod_load_order = true
|
||||
31
.test/run.sh
31
.test/run.sh
@ -1,31 +0,0 @@
|
||||
#!/bin/bash
|
||||
tempdir=$(mktemp -d)
|
||||
confpath=$tempdir/minetest.conf
|
||||
worldpath=$tempdir/world
|
||||
trap 'rm -rf "$tempdir" || :' EXIT
|
||||
|
||||
[ -f mesecons/mod.conf ] || { echo "Must be run in modpack root folder." >&2; exit 1; }
|
||||
|
||||
command -v docker >/dev/null || { echo "Docker is not installed." >&2; exit 1; }
|
||||
mtg=.test/minetest_game
|
||||
[ -d $mtg ] || echo "A source checkout of minetest_game was not found. This can fail if your docker image does not ship a game." >&2
|
||||
|
||||
mkdir "$worldpath"
|
||||
cp -v .test/minetest.conf "$confpath"
|
||||
chmod -R 777 "$tempdir"
|
||||
|
||||
args=(
|
||||
-v "$confpath":/etc/minetest/minetest.conf
|
||||
-v "$tempdir":/var/lib/minetest/.minetest
|
||||
-v "$PWD":/var/lib/minetest/.minetest/world/worldmods/mesecons
|
||||
)
|
||||
[ -d $mtg ] && args+=(
|
||||
-v "$(realpath $mtg)":/var/lib/minetest/.minetest/games/minetest_game
|
||||
)
|
||||
args+=("$DOCKER_IMAGE")
|
||||
[ -d $mtg ] && args+=(--gameid minetest)
|
||||
docker run --rm -i "${args[@]}"
|
||||
|
||||
ls -la "$worldpath"
|
||||
test -f "$worldpath/mesecon_actionqueue" || exit 1
|
||||
exit 0
|
||||
@ -1,156 +0,0 @@
|
||||
mineunit("core")
|
||||
mineunit("server")
|
||||
mineunit("voxelmanip")
|
||||
|
||||
mineunit:set_current_modname("mesecons")
|
||||
mineunit:set_modpath("mesecons", "../mesecons")
|
||||
sourcefile("../mesecons/init")
|
||||
|
||||
-- Utility node: this conductor is used to test the connectivity and state of adjacent wires.
|
||||
do
|
||||
local off_spec = {conductor = {
|
||||
state = mesecon.state.off,
|
||||
rules = mesecon.rules.alldirs,
|
||||
onstate = "mesecons:test_conductor_on",
|
||||
}}
|
||||
local on_spec = {conductor = {
|
||||
state = mesecon.state.on,
|
||||
rules = mesecon.rules.alldirs,
|
||||
offstate = "mesecons:test_conductor_off",
|
||||
}}
|
||||
mesecon.register_node("mesecons:test_conductor", {
|
||||
description = "Test Conductor",
|
||||
}, {mesecons = off_spec}, {mesecons = on_spec})
|
||||
end
|
||||
|
||||
-- Utility node: this receptor is used to test power sources.
|
||||
do
|
||||
local off_spec = {receptor = {
|
||||
state = mesecon.state.off,
|
||||
rules = mesecon.rules.alldirs,
|
||||
}}
|
||||
local on_spec = {receptor = {
|
||||
state = mesecon.state.on,
|
||||
rules = mesecon.rules.alldirs,
|
||||
}}
|
||||
mesecon.register_node("mesecons:test_receptor", {
|
||||
description = "Test Receptor",
|
||||
}, {mesecons = off_spec}, {mesecons = on_spec})
|
||||
end
|
||||
|
||||
-- Utility node: this effector is used to test circuit outputs.
|
||||
do
|
||||
-- This is a list of actions in the form {<kind>, <pos>},
|
||||
-- where <kind> is "on", "off", or "overheat".
|
||||
mesecon._test_effector_events = {}
|
||||
local function action_on(pos, node)
|
||||
table.insert(mesecon._test_effector_events, {"on", pos})
|
||||
node.param2 = node.param2 % 64 + 128 -- Turn on bit 7
|
||||
minetest.swap_node(pos, node)
|
||||
end
|
||||
local function action_off(pos, node)
|
||||
table.insert(mesecon._test_effector_events, {"off", pos})
|
||||
node.param2 = node.param2 % 64 -- Turn off bit 7
|
||||
minetest.swap_node(pos, node)
|
||||
end
|
||||
local function action_change(pos, node, rule_name, new_state)
|
||||
if mesecon.do_overheat(pos) then
|
||||
table.insert(mesecon._test_effector_events, {"overheat", pos})
|
||||
minetest.remove_node(pos)
|
||||
return
|
||||
end
|
||||
-- Set the value of a bit in param2 according to the rule name and new state.
|
||||
local bit = tonumber(rule_name.name, 2)
|
||||
local bits_above = node.param2 - node.param2 % (bit * 2)
|
||||
local bits_below = node.param2 % bit
|
||||
local bits_flipped = new_state == mesecon.state.on and bit or 0
|
||||
node.param2 = bits_above + bits_flipped + bits_below
|
||||
minetest.swap_node(pos, node)
|
||||
end
|
||||
minetest.register_node("mesecons:test_effector", {
|
||||
description = "Test Effector",
|
||||
mesecons = {effector = {
|
||||
action_on = action_on,
|
||||
action_off = action_off,
|
||||
action_change = action_change,
|
||||
rules = {
|
||||
{x = 1, y = 0, z = 0, name = "000001"},
|
||||
{x = -1, y = 0, z = 0, name = "000010"},
|
||||
{x = 0, y = 1, z = 0, name = "000100"},
|
||||
{x = 0, y = -1, z = 0, name = "001000"},
|
||||
{x = 0, y = 0, z = 1, name = "010000"},
|
||||
{x = 0, y = 0, z = -1, name = "100000"},
|
||||
}
|
||||
}},
|
||||
})
|
||||
end
|
||||
|
||||
-- Utility node: this conductor is used to test rotation.
|
||||
do
|
||||
local get_rules = mesecon.horiz_rules_getter({{x = 1, y = 0, z = 0}, {x = -1, y = 0, z = 0}})
|
||||
local off_spec = {conductor = {
|
||||
state = mesecon.state.off,
|
||||
rules = get_rules,
|
||||
onstate = "mesecons:test_conductor_rot_on",
|
||||
}}
|
||||
local on_spec = {conductor = {
|
||||
state = mesecon.state.on,
|
||||
rules = get_rules,
|
||||
offstate = "mesecons:test_conductor_rot_off",
|
||||
}}
|
||||
mesecon.register_node("mesecons:test_conductor_rot", {
|
||||
description = "Rotatable Test Conductor",
|
||||
on_rotate = mesecon.on_rotate_horiz,
|
||||
}, {mesecons = off_spec}, {mesecons = on_spec})
|
||||
end
|
||||
|
||||
-- Utility node: this is used to test multiple conductors within a single node.
|
||||
do
|
||||
local mesecons_spec = {conductor = {
|
||||
rules = {
|
||||
{{x = 1, y = 0, z = 0}, {x = 0, y = -1, z = 0}},
|
||||
{{x = 0, y = 1, z = 0}, {x = 0, y = 0, z = -1}},
|
||||
{{x = 0, y = 0, z = 1}, {x = -1, y = 0, z = 0}},
|
||||
},
|
||||
states = {
|
||||
"mesecons:test_multiconductor_off", "mesecons:test_multiconductor_001",
|
||||
"mesecons:test_multiconductor_010", "mesecons:test_multiconductor_011",
|
||||
"mesecons:test_multiconductor_100", "mesecons:test_multiconductor_101",
|
||||
"mesecons:test_multiconductor_110", "mesecons:test_multiconductor_on",
|
||||
},
|
||||
}}
|
||||
for _, state in ipairs(mesecons_spec.conductor.states) do
|
||||
minetest.register_node(state, {
|
||||
description = "Test Multiconductor",
|
||||
mesecons = mesecons_spec,
|
||||
})
|
||||
end
|
||||
end
|
||||
|
||||
mesecon._test_autoconnects = {}
|
||||
mesecon.register_autoconnect_hook("test", function(pos, node)
|
||||
table.insert(mesecon._test_autoconnects, {pos, node})
|
||||
end)
|
||||
|
||||
function mesecon._test_dig(pos)
|
||||
local node = minetest.get_node(pos)
|
||||
minetest.remove_node(pos)
|
||||
mesecon.on_dignode(pos, node)
|
||||
end
|
||||
|
||||
function mesecon._test_place(pos, node)
|
||||
world.set_node(pos, node)
|
||||
mesecon.on_placenode(pos, minetest.get_node(pos))
|
||||
end
|
||||
|
||||
function mesecon._test_reset()
|
||||
-- First let circuits settle by simulating many globalsteps.
|
||||
for i = 1, 10 do
|
||||
mineunit:execute_globalstep(60)
|
||||
end
|
||||
mesecon.queue.actions = {}
|
||||
mesecon._test_effector_events = {}
|
||||
mesecon._test_autoconnects = {}
|
||||
end
|
||||
|
||||
mineunit:execute_globalstep(mesecon.setting("resumetime", 4) + 1)
|
||||
@ -1,59 +0,0 @@
|
||||
mineunit("player")
|
||||
|
||||
fixture("mesecons")
|
||||
fixture("mesecons_gamecompat")
|
||||
|
||||
local registered_on_player_receive_fields = {}
|
||||
local old_register_on_player_receive_fields = minetest.register_on_player_receive_fields
|
||||
function minetest.register_on_player_receive_fields(func)
|
||||
old_register_on_player_receive_fields(func)
|
||||
table.insert(registered_on_player_receive_fields, func)
|
||||
end
|
||||
|
||||
mineunit:set_current_modname("mesecons_fpga")
|
||||
mineunit:set_modpath("mesecons_fpga", "../mesecons_fpga")
|
||||
sourcefile("../mesecons_fpga/init")
|
||||
|
||||
local fpga_user = Player("mesecons_fpga_user")
|
||||
|
||||
function mesecon._test_program_fpga(pos, program)
|
||||
local node = minetest.get_node(pos)
|
||||
assert.equal("mesecons_fpga:fpga", node.name:sub(1, 18))
|
||||
|
||||
local fields = {program = true}
|
||||
for i, instr in ipairs(program) do
|
||||
-- Translate the instruction into formspec fields.
|
||||
local op1, act, op2, dst
|
||||
if #instr == 3 then
|
||||
act, op2, dst = unpack(instr)
|
||||
else
|
||||
assert.equal(4, #instr)
|
||||
op1, act, op2, dst = unpack(instr)
|
||||
end
|
||||
fields[i .. "op1"] = op1
|
||||
fields[i .. "act"] = (" "):rep(4 - #act) .. act
|
||||
fields[i .. "op2"] = op2
|
||||
fields[i .. "dst"] = dst
|
||||
end
|
||||
|
||||
minetest.registered_nodes[node.name].on_rightclick(pos, node, fpga_user)
|
||||
|
||||
for _, func in ipairs(registered_on_player_receive_fields) do
|
||||
if func(fpga_user, "mesecons:fpga", fields) then
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function mesecon._test_copy_fpga_program(pos)
|
||||
fpga_user:get_inventory():set_stack("main", 1, "mesecons_fpga:programmer")
|
||||
local pt = {type = "node", under = vector.new(pos), above = vector.offset(pos, 0, 1, 0)}
|
||||
fpga_user:do_place(pt)
|
||||
return fpga_user:get_wielded_item()
|
||||
end
|
||||
|
||||
function mesecon._test_paste_fpga_program(pos, tool)
|
||||
fpga_user:get_inventory():set_stack("main", 1, tool)
|
||||
local pt = {type = "node", under = vector.new(pos), above = vector.offset(pos, 0, 1, 0)}
|
||||
fpga_user:do_use(pt)
|
||||
end
|
||||
@ -1,5 +0,0 @@
|
||||
fixture("mesecons")
|
||||
|
||||
mineunit:set_current_modname("mesecons_gamecompat")
|
||||
mineunit:set_modpath("mesecons_gamecompat", "../mesecons_gamecompat")
|
||||
sourcefile("../mesecons_gamecompat/init")
|
||||
@ -1,12 +0,0 @@
|
||||
fixture("mesecons")
|
||||
fixture("mesecons_gamecompat")
|
||||
|
||||
mineunit:set_current_modname("mesecons_luacontroller")
|
||||
mineunit:set_modpath("mesecons_luacontroller", "../mesecons_luacontroller")
|
||||
sourcefile("../mesecons_luacontroller/init")
|
||||
|
||||
function mesecon._test_program_luac(pos, code)
|
||||
local node = minetest.get_node(pos)
|
||||
assert.equal("mesecons_luacontroller:luacontroller", node.name:sub(1, 36))
|
||||
return minetest.registered_nodes[node.name].mesecons.luacontroller.set_program(pos, code)
|
||||
end
|
||||
@ -1,45 +0,0 @@
|
||||
mineunit("protection")
|
||||
|
||||
fixture("mesecons")
|
||||
|
||||
mineunit:set_current_modname("mesecons_mvps")
|
||||
mineunit:set_modpath("mesecons_mvps", "../mesecons_mvps")
|
||||
sourcefile("../mesecons_mvps/init")
|
||||
|
||||
minetest.register_node("mesecons_mvps:test_stopper", {
|
||||
description = "Test Stopper",
|
||||
})
|
||||
mesecon.register_mvps_stopper("mesecons_mvps:test_stopper")
|
||||
|
||||
minetest.register_node("mesecons_mvps:test_stopper_cond", {
|
||||
description = "Test Stopper (Conditional)",
|
||||
})
|
||||
mesecon.register_mvps_stopper("mesecons_mvps:test_stopper_cond", function(node)
|
||||
return node.param2 == 0
|
||||
end)
|
||||
|
||||
minetest.register_node("mesecons_mvps:test_sticky", {
|
||||
description = "Test Sticky",
|
||||
mvps_sticky = function(pos)
|
||||
local connected = {}
|
||||
for i, rule in ipairs(mesecon.rules.alldirs) do
|
||||
connected[i] = vector.add(pos, rule)
|
||||
end
|
||||
return connected
|
||||
end,
|
||||
})
|
||||
|
||||
mesecon._test_moves = {}
|
||||
minetest.register_node("mesecons_mvps:test_on_move", {
|
||||
description = "Test Moveable",
|
||||
mesecon = {
|
||||
on_mvps_move = function(pos, node, oldpos, meta)
|
||||
table.insert(mesecon._test_moves, {pos, node, oldpos, meta})
|
||||
end
|
||||
},
|
||||
})
|
||||
local old_reset = mesecon._test_reset
|
||||
function mesecon._test_reset()
|
||||
mesecon._test_moves = {}
|
||||
old_reset()
|
||||
end
|
||||
@ -1,6 +0,0 @@
|
||||
mineunit:set_current_modname("screwdriver")
|
||||
|
||||
screwdriver = {}
|
||||
|
||||
screwdriver.ROTATE_FACE = 1
|
||||
screwdriver.ROTATE_AXIS = 2
|
||||
30
COPYING.txt
30
COPYING.txt
@ -1,30 +0,0 @@
|
||||
The Mesecons Mod for Minetest is
|
||||
Copyright (C) 2011-2016 Mesecons Mod Developer Team and contributors
|
||||
|
||||
See the version control system log for information about other authors.
|
||||
|
||||
License of source code
|
||||
----------------------
|
||||
Copyright (C) 2011-2016 Mesecons Mod Developer Team and contributors
|
||||
|
||||
This program is free software; you can redistribute the Mesecons Mod and/or
|
||||
modify it under the terms of the GNU Lesser General Public License version 3
|
||||
published by the Free Software Foundation.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
||||
Boston, MA 02110-1301, USA.
|
||||
|
||||
License of media (textures, sounds and documentation)
|
||||
-----------------------------------------------------
|
||||
Copyright (C) 2011-2016 Mesecons Mod Developer Team and contributors
|
||||
|
||||
All textures, sounds and documentation files are licensed under the
|
||||
Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
|
||||
http://creativecommons.org/licenses/by-sa/3.0/
|
||||
@ -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
|
||||
|
||||
36
README.md
36
README.md
@ -12,27 +12,23 @@ MESECONS by Jeija and contributors
|
||||
|
||||
Mezzee-what?
|
||||
------------
|
||||
[Mesecons](http://mesecons.net/)! They're yellow, they're conductive, and they'll add a whole new dimension to Minetest's gameplay.
|
||||
|
||||
[Mesecons](https://mesecons.net/)! They're yellow, they're conductive, and they'll add a whole new dimension to Minetest's gameplay.
|
||||
|
||||
Mesecons is a mod for [Minetest](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.
|
||||
|
||||
OK, I want in.
|
||||
--------------
|
||||
|
||||
Go get it!
|
||||
|
||||
[](https://content.minetest.net/packages/Jeija/mesecons/)
|
||||
[DOWNLOADS PAGE](http://mesecons.net/downloads.php)
|
||||
|
||||
Install it directly from your client by searching it in the Online Content tab.
|
||||
|
||||
**Or** if you've downloaded a ZIP file check out [this page](https://wiki.minetest.net/Mods) over at the official Minetest Wiki. For your convenience, here's a quick summary:
|
||||
Now go ahead and install it like any other Minetest mod. Don't know how? Check out [the wonderful page about it](http://wiki.minetest.com/wiki/Mods) over at the Minetest Wiki. For your convenience, here's a quick summary:
|
||||
|
||||
1. If Mesecons is still in a ZIP file, extract the folder inside to somewhere on the computer.
|
||||
2. Make sure that when you open the folder, you can directly find `README.md` in the listing. If you just see another folder, move that folder up one level and delete the old one.
|
||||
3. Open up the Minetest mods folder - called `mods`.
|
||||
3. Open up the Minetest mods folder - usually `/mods/`. If you see the `minetest` or folder inside of that, that is your mod folder instead.
|
||||
4. Copy the Mesecons folder into the mods folder.
|
||||
|
||||
Don't like some parts of Mesecons? Open up the Mesecons folder and delete the subfolder containing the mod you don't want. If you didn't want movestones, for example, all you have to do is delete the `mesecons_movestones` folder and they will no longer be available.
|
||||
@ -41,25 +37,22 @@ There are no dependencies - it will work right after installing!
|
||||
|
||||
How do I use this thing?
|
||||
------------------------
|
||||
|
||||
How about a [quick overview video](https://www.youtube.com/watch?v=6kmeQj6iW5k)?
|
||||
|
||||
Or maybe a [comprehensive reference](https://mesecons.net/items.html) is your style?
|
||||
Or maybe a [comprehensive reference](http://mesecons.net/items.php) is your style?
|
||||
|
||||
An overview for the very newest of new beginners? How does [this one](https://uberi.mesecons.net/projects/MeseconsBasics/index.html) look?
|
||||
An overview for the very newest of new beginners? How does [this one](http://uberi.mesecons.net/projects/MeseconsBasics/index.html) look?
|
||||
|
||||
Want to get more into building? Why not check out the [Mesecons Laboratory](https://uberi.mesecons.net/), a website dedicated to advanced Mesecons builders?
|
||||
Want to get more into building? Why not check out the [Mesecons Laboratory](http://uberi.mesecons.net/), a website dedicated to advanced Mesecons builders?
|
||||
|
||||
Want to contribute to Mesecons itself? Check out the [source code](https://github.com/minetest-mods/mesecons)!
|
||||
Want to contribute to Mesecons itself? Check out the [source code](https://github.com/Jeija/minetest-mod-mesecons)!
|
||||
|
||||
Who wrote it anyways?
|
||||
---------------------
|
||||
|
||||
These awesome people made Mesecons possible! (as of 2016)
|
||||
These awesome people made Mesecons possible!
|
||||
|
||||
| Contributor | Contribution |
|
||||
| --------------- | -------------------------------- |
|
||||
| Hawk777 | Code for VoxelManip caching |
|
||||
| Jat15 | Various tweaks. |
|
||||
| Jeija | **Main developer! Everything.** |
|
||||
| Jordach | Noteblock sounds. |
|
||||
@ -76,15 +69,10 @@ These awesome people made Mesecons possible! (as of 2016)
|
||||
|
||||
There are also a whole bunch of other people helping with everything from code to testing and feedback. Mesecons would also not be possible without their help!
|
||||
|
||||
Check out the [entire contributor list](https://github.com/minetest-mods/mesecons/graphs/contributors) on GitHub.
|
||||
|
||||
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.
|
||||
|
||||
12
bower.json
12
bower.json
@ -1,12 +0,0 @@
|
||||
{
|
||||
"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",
|
||||
"keywords": [
|
||||
"mesecons",
|
||||
"minetest",
|
||||
"mod"
|
||||
]
|
||||
}
|
||||
@ -1,65 +0,0 @@
|
||||
{
|
||||
"Conductors" : {
|
||||
"Mesecon" : "mesecons_wires/doc/mesecon",
|
||||
"Insulated Wire" : "mesecons_insulated/doc/insulated",
|
||||
"T-Junction" : "mesecons_extrawires/doc/tjunction",
|
||||
"Crossing" : "mesecons_extrawires/doc/crossing",
|
||||
"Corner" : "mesecons_extrawires/doc/corner",
|
||||
"Vertical Wire" : "mesecons_extrawires/doc/vertical",
|
||||
"Mese" : "mesecons_extrawires/doc/mese"
|
||||
},
|
||||
"Receptors" : {
|
||||
"Power Plant" : "mesecons_powerplant/doc/powerplant",
|
||||
"Blinky Plant" : "mesecons_blinkyplant/doc/blinkyplant",
|
||||
"Switch" : "mesecons_switch/doc/switch",
|
||||
"Object Detector" : "mesecons_detector/doc/objectdetector",
|
||||
"Node Detector" : "mesecons_detector/doc/nodedetector",
|
||||
"Wall Lever" : "mesecons_walllever/doc/walllever",
|
||||
"Pressure Plate" : "mesecons_pressureplates/doc/pressureplate_wood",
|
||||
"Pressure Plate" : "mesecons_pressureplates/doc/pressureplate_stone",
|
||||
"Water Turbine" : "mesecons_hydroturbine/doc/waterturbine",
|
||||
"Solar Panel" : "mesecons_solarpanel/doc/solarpanel",
|
||||
"Wall Button" : "mesecons_button/doc/button"
|
||||
},
|
||||
"Effectors" : {
|
||||
"Noteblock" : "mesecons_noteblock/doc/noteblock",
|
||||
"Lamp" : "mesecons_lamp/doc/lamp",
|
||||
"Piston" : "mesecons_pistons/doc/piston",
|
||||
"Sticky Piston" : "mesecons_pistons/doc/piston_sticky",
|
||||
"Movestone" : "mesecons_movestones/doc/movestone",
|
||||
"Sticky Movestone" : "mesecons_movestones/doc/movestone_sticky",
|
||||
"Removestone" : "mesecons_random/doc/removestone",
|
||||
"Ghoststone" : "mesecons_random/doc/ghoststone",
|
||||
"Command Block" : "mesecons_commandblock/doc/commandblock",
|
||||
"Lightstones" : {
|
||||
"Dark Grey" : "mesecons_lightstone/doc/lightstone_darkgrey",
|
||||
"Light Grey" : "mesecons_lightstone/doc/lightstone_lightgrey",
|
||||
"Green" : "mesecons_lightstone/doc/lightstone_green",
|
||||
"Red" : "mesecons_lightstone/doc/lightstone_red",
|
||||
"Blue" : "mesecons_lightstone/doc/lightstone_blue",
|
||||
"Yellow" : "mesecons_lightstone/doc/lightstone_yellow"
|
||||
}
|
||||
},
|
||||
"Logic" : {
|
||||
"Luacontroller" : "mesecons_luacontroller/doc/luacontroller",
|
||||
"Microcontroller" : "mesecons_microcontroller/doc/microcontroler",
|
||||
"FPGA" : "mesecons_fpga/doc/fpga",
|
||||
"FPGA Programmer" : "mesecons_fpga/doc/programmer",
|
||||
"Torch" : "mesecons_torch/doc/torch",
|
||||
"Delayer" : "mesecons_delayer/doc/delayer",
|
||||
"Gates" : {
|
||||
"Diode" : "mesecons_gates/doc/diode",
|
||||
"NOT Gate" : "mesecons_gates/doc/not",
|
||||
"AND Gate" : "mesecons_gates/doc/and",
|
||||
"NAND Gate" : "mesecons_gates/doc/nand",
|
||||
"OR Gate" : "mesecons_gates/doc/or",
|
||||
"NOR Gate" : "mesecons_gates/doc/nor",
|
||||
"XOR Gate" : "mesecons_gates/doc/xor"
|
||||
}
|
||||
},
|
||||
"Crafts" : {
|
||||
"Silicon" : "mesecons_materials/doc/silicon",
|
||||
"Glue" : "mesecons_materials/doc/glue",
|
||||
"Fiber" : "mesecons_materials/doc/fiber"
|
||||
}
|
||||
}
|
||||
1
mesecons/VERSION
Normal file
1
mesecons/VERSION
Normal file
@ -0,0 +1 @@
|
||||
0.41 DEV
|
||||
@ -1,143 +1,118 @@
|
||||
--[[
|
||||
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(mesecon.cmpPos(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
|
||||
|
||||
return highesti
|
||||
end
|
||||
|
||||
local m_time = 0
|
||||
local resumetime = mesecon.setting("resumetime", 4)
|
||||
|
||||
local function globalstep_func(dtime)
|
||||
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
|
||||
m_time = m_time + dtime
|
||||
return
|
||||
end
|
||||
if (m_time < resumetime) then return end
|
||||
local actions = mesecon.tablecopy(mesecon.queue.actions)
|
||||
local actions_now={}
|
||||
|
||||
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 = {}
|
||||
mesecon.queue.actions = {}
|
||||
|
||||
for _, ac in ipairs(actions) do
|
||||
-- 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
|
||||
|
||||
minetest.register_globalstep(globalstep_func)
|
||||
|
||||
function queue:execute(action)
|
||||
-- ignore if action queue function name doesn't exist,
|
||||
-- (e.g. in case the action queue savegame was written by an old mesecons version)
|
||||
if self.funcs[action.func] then
|
||||
self.funcs[action.func](action.pos, unpack(action.params))
|
||||
end
|
||||
function mesecon.queue:execute(action)
|
||||
mesecon.queue.funcs[action.func](action.pos, unpack(action.params))
|
||||
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")
|
||||
|
||||
local wpath = minetest.get_worldpath()
|
||||
local function file2table(filename)
|
||||
local f = io.open(filename, "r")
|
||||
if f==nil then return {} end
|
||||
local t = f:read("*all")
|
||||
f:close()
|
||||
if t=="" or t==nil then return {} end
|
||||
return minetest.deserialize(t)
|
||||
end
|
||||
|
||||
local function table2file(filename, table)
|
||||
local f = io.open(filename, "w")
|
||||
f:write(minetest.serialize(table))
|
||||
f:close()
|
||||
end
|
||||
|
||||
mesecon.queue.actions = file2table(wpath.."/mesecon_actionqueue")
|
||||
|
||||
minetest.register_on_shutdown(function()
|
||||
mesecon.table2file("mesecon_actionqueue", queue.actions)
|
||||
mesecon.queue.actions = table2file(wpath.."/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
|
||||
@ -3,7 +3,7 @@
|
||||
-- | \/ | |___ ____ |___ | | | | \ | |____
|
||||
-- | | | | | | | | | \ | |
|
||||
-- | | |___ ____| |___ |____ |____| | \| ____|
|
||||
-- by Jeija, Uberi (Temperest), sfan5, VanessaE, Hawk777 and contributors
|
||||
-- by Jeija, Uberi (Temperest), sfan5, VanessaE
|
||||
--
|
||||
--
|
||||
--
|
||||
@ -11,7 +11,7 @@
|
||||
-- See the documentation on the forum for additional information, especially about crafting
|
||||
--
|
||||
--
|
||||
-- For basic development resources, see http://mesecons.net/developers.html
|
||||
-- For developer documentation see the Developers' section on mesecons.TK
|
||||
--
|
||||
--
|
||||
--
|
||||
@ -70,20 +70,26 @@ dofile(minetest.get_modpath("mesecons").."/internal.lua");
|
||||
-- these are the only functions you need to remember
|
||||
|
||||
mesecon.queue:add_function("receptor_on", function (pos, rules)
|
||||
mesecon.vm_begin()
|
||||
|
||||
rules = rules or mesecon.rules.default
|
||||
|
||||
-- Call turnon on all linking positions
|
||||
-- if area (any of the rule targets) is not loaded, keep trying and call this again later
|
||||
for _, rule in ipairs(mesecon.flattenrules(rules)) do
|
||||
local np = vector.add(pos, rule)
|
||||
local np = mesecon.addPosRule(pos, rule)
|
||||
-- if area is not loaded, keep trying
|
||||
if minetest.get_node_or_nil(np) == nil then
|
||||
mesecon.queue:add_action(pos, "receptor_on", {rules}, nil, rules)
|
||||
return
|
||||
end
|
||||
end
|
||||
|
||||
-- execute action
|
||||
for _, rule in ipairs(mesecon.flattenrules(rules)) do
|
||||
local np = mesecon.addPosRule(pos, rule)
|
||||
local rulenames = mesecon.rules_link_rule_all(pos, rule)
|
||||
for _, rulename in ipairs(rulenames) do
|
||||
mesecon.turnon(np, rulename)
|
||||
end
|
||||
end
|
||||
|
||||
mesecon.vm_commit()
|
||||
end)
|
||||
|
||||
function mesecon.receptor_on(pos, rules)
|
||||
@ -93,20 +99,23 @@ end
|
||||
mesecon.queue:add_function("receptor_off", function (pos, rules)
|
||||
rules = rules or mesecon.rules.default
|
||||
|
||||
-- Call turnoff on all linking positions
|
||||
-- if area (any of the rule targets) is not loaded, keep trying and call this again later
|
||||
for _, rule in ipairs(mesecon.flattenrules(rules)) do
|
||||
local np = vector.add(pos, rule)
|
||||
local np = mesecon.addPosRule(pos, rule)
|
||||
if minetest.get_node_or_nil(np) == nil then
|
||||
mesecon.queue:add_action(pos, "receptor_off", {rules}, nil, rules)
|
||||
return
|
||||
end
|
||||
end
|
||||
|
||||
for _, rule in ipairs(mesecon.flattenrules(rules)) do
|
||||
local np = mesecon.addPosRule(pos, rule)
|
||||
local rulenames = mesecon.rules_link_rule_all(pos, rule)
|
||||
for _, rulename in ipairs(rulenames) do
|
||||
mesecon.vm_begin()
|
||||
|
||||
-- Turnoff returns true if turnoff process was successful, no onstate receptor
|
||||
-- was found along the way. Commit changes that were made in voxelmanip. If turnoff
|
||||
-- returns true, an onstate receptor was found, abort voxelmanip transaction.
|
||||
if (mesecon.turnoff(np, rulename)) then
|
||||
mesecon.vm_commit()
|
||||
if not mesecon.connected_to_receptor(np, mesecon.invertRule(rule)) then
|
||||
mesecon.turnoff(np, rulename)
|
||||
else
|
||||
mesecon.vm_abort()
|
||||
mesecon.changesignal(np, minetest.get_node(np), rulename, mesecon.state.off, 2)
|
||||
end
|
||||
end
|
||||
end
|
||||
@ -117,17 +126,14 @@ function mesecon.receptor_off(pos, rules)
|
||||
end
|
||||
|
||||
|
||||
print("[OK] Mesecons")
|
||||
|
||||
-- Deprecated stuff
|
||||
-- To be removed in future releases
|
||||
dofile(minetest.get_modpath("mesecons").."/legacy.lua");
|
||||
|
||||
--The actual wires
|
||||
dofile(minetest.get_modpath("mesecons").."/wires.lua");
|
||||
|
||||
--Services like turnoff receptor on dignode and so on
|
||||
dofile(minetest.get_modpath("mesecons").."/services.lua");
|
||||
|
||||
-- Automated test run
|
||||
if mesecon.setting("internal_test", false) then
|
||||
-- currently does nothing, we only fail if some error happens right on startup
|
||||
minetest.after(5, function()
|
||||
minetest.request_shutdown()
|
||||
end)
|
||||
end
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -37,6 +37,11 @@
|
||||
-- HIGH-LEVEL Internals
|
||||
-- mesecon.is_power_on(pos) --> Returns true if pos emits power in any way
|
||||
-- mesecon.is_power_off(pos) --> Returns true if pos does not emit power in any way
|
||||
-- mesecon.turnon(pos, link) --> link is the input rule that caused calling turnon, turns on every connected node, iterative
|
||||
-- mesecon.turnoff(pos, link) --> link is the input rule that caused calling turnoff, turns off every connected node, iterative
|
||||
-- mesecon.connected_to_receptor(pos, link) --> Returns true if pos is connected to a receptor directly or via conductors, iterative
|
||||
-- mesecon.rules_link(output, input, dug_outputrules) --> Returns true if outputposition + outputrules = inputposition and inputposition + inputrules = outputposition (if the two positions connect)
|
||||
-- mesecon.rules_link_anydir(outp., inp., d_outpr.) --> Same as rules mesecon.rules_link but also returns true if output and input are swapped
|
||||
-- mesecon.is_powered(pos) --> Returns true if pos is powered by a receptor or a conductor
|
||||
|
||||
-- RULES ROTATION helpers
|
||||
@ -46,28 +51,32 @@
|
||||
-- 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)
|
||||
local def = minetest.registered_nodes[nodename]
|
||||
return def and def.mesecons and def.mesecons.effector
|
||||
if minetest.registered_nodes[nodename]
|
||||
and minetest.registered_nodes[nodename].mesecons
|
||||
and minetest.registered_nodes[nodename].mesecons.effector then
|
||||
return minetest.registered_nodes[nodename].mesecons.effector
|
||||
end
|
||||
end
|
||||
|
||||
function mesecon.get_receptor(nodename)
|
||||
local def = minetest.registered_nodes[nodename]
|
||||
return def and def.mesecons and def.mesecons.receptor
|
||||
if minetest.registered_nodes[nodename]
|
||||
and minetest.registered_nodes[nodename].mesecons
|
||||
and minetest.registered_nodes[nodename].mesecons.receptor then
|
||||
return minetest.registered_nodes[nodename].mesecons.receptor
|
||||
end
|
||||
end
|
||||
|
||||
function mesecon.get_conductor(nodename)
|
||||
local def = minetest.registered_nodes[nodename]
|
||||
return def and def.mesecons and def.mesecons.conductor
|
||||
if minetest.registered_nodes[nodename]
|
||||
and minetest.registered_nodes[nodename].mesecons
|
||||
and minetest.registered_nodes[nodename].mesecons.conductor then
|
||||
return minetest.registered_nodes[nodename].mesecons.conductor
|
||||
end
|
||||
end
|
||||
|
||||
function mesecon.get_any_outputrules(node)
|
||||
if not node then return nil end
|
||||
|
||||
function mesecon.get_any_outputrules (node)
|
||||
if mesecon.is_conductor(node.name) then
|
||||
return mesecon.conductor_get_rules(node)
|
||||
elseif mesecon.is_receptor(node.name) then
|
||||
@ -75,9 +84,7 @@ function mesecon.get_any_outputrules(node)
|
||||
end
|
||||
end
|
||||
|
||||
function mesecon.get_any_inputrules(node)
|
||||
if not node then return nil end
|
||||
|
||||
function mesecon.get_any_inputrules (node)
|
||||
if mesecon.is_conductor(node.name) then
|
||||
return mesecon.conductor_get_rules(node)
|
||||
elseif mesecon.is_effector(node.name) then
|
||||
@ -85,9 +92,9 @@ function mesecon.get_any_inputrules(node)
|
||||
end
|
||||
end
|
||||
|
||||
function mesecon.get_any_rules(node)
|
||||
return mesecon.merge_rule_sets(mesecon.get_any_inputrules(node),
|
||||
mesecon.get_any_outputrules(node))
|
||||
function mesecon.get_any_rules (node)
|
||||
return mesecon.mergetable(mesecon.get_any_inputrules(node) or {},
|
||||
mesecon.get_any_outputrules(node) or {})
|
||||
end
|
||||
|
||||
-- Receptors
|
||||
@ -175,9 +182,7 @@ end
|
||||
|
||||
-- Activation:
|
||||
mesecon.queue:add_function("activate", function (pos, rulename)
|
||||
local node = mesecon.get_node_force(pos)
|
||||
if not node then return end
|
||||
|
||||
local node = minetest.get_node(pos)
|
||||
local effector = mesecon.get_effector(node.name)
|
||||
|
||||
if effector and effector.action_on then
|
||||
@ -198,9 +203,7 @@ end
|
||||
|
||||
-- Deactivation
|
||||
mesecon.queue:add_function("deactivate", function (pos, rulename)
|
||||
local node = mesecon.get_node_force(pos)
|
||||
if not node then return end
|
||||
|
||||
local node = minetest.get_node(pos)
|
||||
local effector = mesecon.get_effector(node.name)
|
||||
|
||||
if effector and effector.action_off then
|
||||
@ -221,9 +224,7 @@ end
|
||||
|
||||
-- Change
|
||||
mesecon.queue:add_function("change", function (pos, rulename, changetype)
|
||||
local node = mesecon.get_node_force(pos)
|
||||
if not node then return end
|
||||
|
||||
local node = minetest.get_node(pos)
|
||||
local effector = mesecon.get_effector(node.name)
|
||||
|
||||
if effector and effector.action_change then
|
||||
@ -248,8 +249,6 @@ end
|
||||
-- Conductors
|
||||
|
||||
function mesecon.is_conductor_on(node, rulename)
|
||||
if not node then return false end
|
||||
|
||||
local conductor = mesecon.get_conductor(node.name)
|
||||
if conductor then
|
||||
if conductor.state then
|
||||
@ -264,13 +263,10 @@ function mesecon.is_conductor_on(node, rulename)
|
||||
return mesecon.get_bit(binstate, bit)
|
||||
end
|
||||
end
|
||||
|
||||
return false
|
||||
end
|
||||
|
||||
function mesecon.is_conductor_off(node, rulename)
|
||||
if not node then return false end
|
||||
|
||||
local conductor = mesecon.get_conductor(node.name)
|
||||
if conductor then
|
||||
if conductor.state then
|
||||
@ -285,7 +281,6 @@ function mesecon.is_conductor_off(node, rulename)
|
||||
return not mesecon.get_bit(binstate, bit)
|
||||
end
|
||||
end
|
||||
|
||||
return false
|
||||
end
|
||||
|
||||
@ -310,7 +305,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)
|
||||
@ -326,7 +321,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)
|
||||
@ -345,212 +340,195 @@ end
|
||||
-- some more general high-level stuff
|
||||
|
||||
function mesecon.is_power_on(pos, rulename)
|
||||
local node = mesecon.get_node_force(pos)
|
||||
if node and (mesecon.is_conductor_on(node, rulename) or mesecon.is_receptor_on(node.name)) then
|
||||
local node = minetest.get_node(pos)
|
||||
if mesecon.is_conductor_on(node, rulename) or mesecon.is_receptor_on(node.name) then
|
||||
return true
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
function mesecon.is_power_off(pos, rulename)
|
||||
local node = mesecon.get_node_force(pos)
|
||||
if node and (mesecon.is_conductor_off(node, rulename) or mesecon.is_receptor_off(node.name)) then
|
||||
local node = minetest.get_node(pos)
|
||||
if mesecon.is_conductor_off(node, rulename) or mesecon.is_receptor_off(node.name) then
|
||||
return true
|
||||
end
|
||||
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
|
||||
local node = mesecon.get_node_force(f.pos)
|
||||
while frontiers[depth] do
|
||||
local f = frontiers[depth]
|
||||
local node = minetest.get_node_or_nil(f.pos)
|
||||
|
||||
-- area not loaded, postpone action
|
||||
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
|
||||
mesecon.queue:add_action(f.pos, "turnon", {link}, nil, true)
|
||||
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
|
||||
minetest.swap_node(f.pos, {name = mesecon.get_conductor_on(node, f.link),
|
||||
param2 = node.param2})
|
||||
|
||||
-- call turnon on neighbors: normal rules
|
||||
for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
|
||||
local np = mesecon.addPosRule(f.pos, r)
|
||||
|
||||
-- area not loaded, postpone action
|
||||
if not minetest.get_node_or_nil(np) then
|
||||
mesecon.queue:add_action(np, "turnon", {rulename},
|
||||
nil, true)
|
||||
else
|
||||
local links = mesecon.rules_link_rule_all(f.pos, r)
|
||||
for _, l in ipairs(links) do
|
||||
table.insert(frontiers, {pos = np, link = l})
|
||||
end
|
||||
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
|
||||
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
|
||||
end
|
||||
|
||||
-- Turn on an equipotential section starting at `pos`, which outputs in the direction of `link`.
|
||||
-- Breadth-first search. Map is abstracted away in a voxelmanip.
|
||||
-- Follow all all conductor paths replacing conductors that were already
|
||||
-- looked at, deactivating / changing all effectors along the way.
|
||||
-- In case an onstate receptor is discovered, abort the process by returning false, which will
|
||||
-- cause `receptor_off` to discard all changes made in the voxelmanip.
|
||||
-- Contrary to turnon, turnoff has to cache all change and deactivate signals so that they will only
|
||||
-- be called in the very end when we can be sure that no conductor was found along the path.
|
||||
--
|
||||
-- Signal table entry structure:
|
||||
-- {
|
||||
-- pos = position of effector,
|
||||
-- node = node descriptor (name, param1 and param2),
|
||||
-- link = link the effector is connected to,
|
||||
-- depth = indicates order in which signals wire fired, higher is later
|
||||
-- }
|
||||
function mesecon.turnoff(pos, link)
|
||||
find_light_update_conductors()
|
||||
mesecon.queue:add_function("turnon", function (pos, rulename, recdepth)
|
||||
mesecon.turnon(pos, rulename, recdepth)
|
||||
end)
|
||||
|
||||
local frontiers = mesecon.fifo_queue.new()
|
||||
frontiers:add({pos = pos, link = link})
|
||||
local signals = {}
|
||||
local pos_can_be_skipped = {}
|
||||
function mesecon.turnoff(pos, link)
|
||||
local frontiers = {{pos = pos, link = link}}
|
||||
|
||||
local depth = 1
|
||||
for f in frontiers:iter() do
|
||||
local node = mesecon.get_node_force(f.pos)
|
||||
while frontiers[depth] do
|
||||
local f = frontiers[depth]
|
||||
local node = minetest.get_node_or_nil(f.pos)
|
||||
|
||||
-- area not loaded, postpone action
|
||||
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
|
||||
mesecon.queue:add_action(f.pos, "turnoff", {link}, nil, true)
|
||||
elseif mesecon.is_conductor_on(node, f.link) then
|
||||
local rules = mesecon.conductor_get_rules(node)
|
||||
|
||||
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)
|
||||
minetest.swap_node(f.pos, {name = mesecon.get_conductor_off(node, f.link),
|
||||
param2 = node.param2})
|
||||
|
||||
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: normal rules
|
||||
for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
|
||||
local np = mesecon.addPosRule(f.pos, r)
|
||||
|
||||
-- Call turnoff on neighbors
|
||||
for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
|
||||
frontiers:add({pos = np, link = l})
|
||||
end
|
||||
-- area not loaded, postpone action
|
||||
if not minetest.get_node_or_nil(np) then
|
||||
mesecon.queue:add_action(np, "turnoff", {rulename},
|
||||
nil, true)
|
||||
else
|
||||
local links = mesecon.rules_link_rule_all(f.pos, r)
|
||||
for _, l in ipairs(links) do
|
||||
table.insert(frontiers, {pos = np, link = l})
|
||||
end
|
||||
end
|
||||
|
||||
mesecon.swap_node_force(f.pos, mesecon.get_conductor_off(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
|
||||
elseif mesecon.is_effector(node.name) then
|
||||
table.insert(signals, {
|
||||
pos = f.pos,
|
||||
node = node,
|
||||
link = f.link,
|
||||
depth = depth
|
||||
})
|
||||
else
|
||||
pos_can_be_skipped[minetest.hash_node_position(f.pos)] = true
|
||||
mesecon.changesignal(f.pos, node, f.link, mesecon.state.off, depth)
|
||||
if mesecon.is_effector_on(node.name) and not mesecon.is_powered(f.pos) then
|
||||
mesecon.deactivate(f.pos, node, f.link, depth)
|
||||
end
|
||||
end
|
||||
depth = depth + 1
|
||||
end
|
||||
end
|
||||
|
||||
for _, sig in ipairs(signals) do
|
||||
-- If sig.depth is 1, it has not yet been checked that the power source is actually off.
|
||||
if sig.depth > 1 or not mesecon.is_powered(sig.pos, sig.link) then
|
||||
mesecon.changesignal(sig.pos, sig.node, sig.link, mesecon.state.off, sig.depth)
|
||||
if mesecon.is_effector_on(sig.node.name) and not mesecon.is_powered(sig.pos) then
|
||||
mesecon.deactivate(sig.pos, sig.node, sig.link, sig.depth)
|
||||
mesecon.queue:add_function("turnoff", function (pos, rulename, recdepth)
|
||||
mesecon.turnoff(pos, rulename, recdepth)
|
||||
end)
|
||||
|
||||
|
||||
function mesecon.connected_to_receptor(pos, link)
|
||||
local node = minetest.get_node(pos)
|
||||
|
||||
-- Check if conductors around are connected
|
||||
local rules = mesecon.get_any_inputrules(node)
|
||||
if not rules then return false end
|
||||
|
||||
for _, rule in ipairs(mesecon.rule2meta(link, rules)) do
|
||||
local links = mesecon.rules_link_rule_all_inverted(pos, rule)
|
||||
for _, l in ipairs(links) do
|
||||
local np = mesecon.addPosRule(pos, l)
|
||||
if mesecon.find_receptor_on(np, mesecon.invertRule(l)) then
|
||||
return true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return true
|
||||
return false
|
||||
end
|
||||
|
||||
function mesecon.find_receptor_on(pos, link)
|
||||
local frontiers = {{pos = pos, link = link}}
|
||||
local checked = {}
|
||||
|
||||
-- List of positions that have been searched for onstate receptors
|
||||
local depth = 1
|
||||
while frontiers[depth] do
|
||||
local f = frontiers[depth]
|
||||
local node = minetest.get_node_or_nil(f.pos)
|
||||
|
||||
if not node then return false end
|
||||
if mesecon.is_receptor_on(node.name) then return true end
|
||||
if mesecon.is_conductor_on(node, f.link) then
|
||||
local rules = mesecon.conductor_get_rules(node)
|
||||
|
||||
-- call turnoff on neighbors: normal rules
|
||||
for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
|
||||
local np = mesecon.addPosRule(f.pos, r)
|
||||
|
||||
local links = mesecon.rules_link_rule_all_inverted(f.pos, r)
|
||||
for _, l in ipairs(links) do
|
||||
local checkedstring = np.x..np.y..np.z..l.x..l.y..l.z
|
||||
if not checked[checkedstring] then
|
||||
table.insert(frontiers, {pos = np, link = l})
|
||||
checked[checkedstring] = true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
depth = depth + 1
|
||||
end
|
||||
end
|
||||
|
||||
function mesecon.rules_link(output, input, dug_outputrules) --output/input are positions (outputrules optional, used if node has been dug), second return value: the name of the affected input rule
|
||||
local outputnode = minetest.get_node(output)
|
||||
local inputnode = minetest.get_node(input)
|
||||
local outputrules = dug_outputrules or mesecon.get_any_outputrules (outputnode)
|
||||
local inputrules = mesecon.get_any_inputrules (inputnode)
|
||||
if not outputrules or not inputrules then
|
||||
return
|
||||
end
|
||||
|
||||
for _, outputrule in ipairs(mesecon.flattenrules(outputrules)) do
|
||||
-- Check if output sends to input
|
||||
if mesecon.cmpPos(mesecon.addPosRule(output, outputrule), input) then
|
||||
for _, inputrule in ipairs(mesecon.flattenrules(inputrules)) do
|
||||
-- Check if input accepts from output
|
||||
if mesecon.cmpPos(mesecon.addPosRule(input, inputrule), output) then
|
||||
return true, inputrule
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
-- Get all linking inputrules of inputnode (effector or conductor) that is connected to
|
||||
-- outputnode (receptor or conductor) at position `output` and has an output in direction `rule`
|
||||
function mesecon.rules_link_rule_all(output, rule)
|
||||
local input = vector.add(output, rule)
|
||||
local inputnode = mesecon.get_node_force(input)
|
||||
local inputrules = mesecon.get_any_inputrules(inputnode)
|
||||
local input = mesecon.addPosRule(output, rule)
|
||||
local inputnode = minetest.get_node(input)
|
||||
local inputrules = mesecon.get_any_inputrules (inputnode)
|
||||
if not inputrules then
|
||||
return {}
|
||||
end
|
||||
@ -558,35 +536,37 @@ function mesecon.rules_link_rule_all(output, rule)
|
||||
|
||||
for _, inputrule in ipairs(mesecon.flattenrules(inputrules)) do
|
||||
-- Check if input accepts from output
|
||||
if vector.equals(vector.add(input, inputrule), output) then
|
||||
if mesecon.cmpPos(mesecon.addPosRule(input, inputrule), output) then
|
||||
table.insert(rules, inputrule)
|
||||
end
|
||||
end
|
||||
|
||||
return rules
|
||||
end
|
||||
|
||||
-- Get all linking outputnodes of outputnode (receptor or conductor) that is connected to
|
||||
-- inputnode (effector or conductor) at position `input` and has an input in direction `rule`
|
||||
function mesecon.rules_link_rule_all_inverted(input, rule)
|
||||
local output = vector.add(input, rule)
|
||||
local outputnode = mesecon.get_node_force(output)
|
||||
local outputrules = mesecon.get_any_outputrules(outputnode)
|
||||
--local irule = mesecon.invertRule(rule)
|
||||
local output = mesecon.addPosRule(input, rule)
|
||||
local outputnode = minetest.get_node(output)
|
||||
local outputrules = mesecon.get_any_outputrules (outputnode)
|
||||
if not outputrules then
|
||||
return {}
|
||||
end
|
||||
local rules = {}
|
||||
|
||||
for _, outputrule in ipairs(mesecon.flattenrules(outputrules)) do
|
||||
if vector.equals(vector.add(output, outputrule), input) then
|
||||
if mesecon.cmpPos(mesecon.addPosRule(output, outputrule), input) then
|
||||
table.insert(rules, mesecon.invertRule(outputrule))
|
||||
end
|
||||
end
|
||||
return rules
|
||||
end
|
||||
|
||||
function mesecon.rules_link_anydir(pos1, pos2)
|
||||
return mesecon.rules_link(pos1, pos2) or mesecon.rules_link(pos2, pos1)
|
||||
end
|
||||
|
||||
function mesecon.is_powered(pos, rule)
|
||||
local node = mesecon.get_node_force(pos)
|
||||
local node = minetest.get_node(pos)
|
||||
local rules = mesecon.get_any_inputrules(node)
|
||||
if not rules then return false end
|
||||
|
||||
@ -597,11 +577,10 @@ function mesecon.is_powered(pos, rule)
|
||||
for _, rule in ipairs(mesecon.flattenrules(rules)) do
|
||||
local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
|
||||
for _, rname in ipairs(rulenames) do
|
||||
local np = vector.add(pos, rname)
|
||||
local nn = mesecon.get_node_force(np)
|
||||
|
||||
if (mesecon.is_conductor_on(nn, mesecon.invertRule(rname))
|
||||
or mesecon.is_receptor_on(nn.name)) then
|
||||
local np = mesecon.addPosRule(pos, rname)
|
||||
local nn = minetest.get_node(np)
|
||||
if (mesecon.is_conductor_on (nn, mesecon.invertRule(rname))
|
||||
or mesecon.is_receptor_on (nn.name)) then
|
||||
table.insert(sourcepos, np)
|
||||
end
|
||||
end
|
||||
@ -609,8 +588,8 @@ function mesecon.is_powered(pos, rule)
|
||||
else
|
||||
local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
|
||||
for _, rname in ipairs(rulenames) do
|
||||
local np = vector.add(pos, rname)
|
||||
local nn = mesecon.get_node_force(np)
|
||||
local np = mesecon.addPosRule(pos, rname)
|
||||
local nn = minetest.get_node(np)
|
||||
if (mesecon.is_conductor_on (nn, mesecon.invertRule(rname))
|
||||
or mesecon.is_receptor_on (nn.name)) then
|
||||
table.insert(sourcepos, np)
|
||||
@ -622,3 +601,52 @@ function mesecon.is_powered(pos, rule)
|
||||
if (#sourcepos == 0) then return false
|
||||
else return sourcepos end
|
||||
end
|
||||
|
||||
--Rules rotation Functions:
|
||||
function mesecon.rotate_rules_right(rules)
|
||||
local nr = {}
|
||||
for i, rule in ipairs(rules) do
|
||||
table.insert(nr, {
|
||||
x = -rule.z,
|
||||
y = rule.y,
|
||||
z = rule.x,
|
||||
name = rule.name})
|
||||
end
|
||||
return nr
|
||||
end
|
||||
|
||||
function mesecon.rotate_rules_left(rules)
|
||||
local nr = {}
|
||||
for i, rule in ipairs(rules) do
|
||||
table.insert(nr, {
|
||||
x = rule.z,
|
||||
y = rule.y,
|
||||
z = -rule.x,
|
||||
name = rule.name})
|
||||
end
|
||||
return nr
|
||||
end
|
||||
|
||||
function mesecon.rotate_rules_down(rules)
|
||||
local nr = {}
|
||||
for i, rule in ipairs(rules) do
|
||||
table.insert(nr, {
|
||||
x = -rule.y,
|
||||
y = rule.x,
|
||||
z = rule.z,
|
||||
name = rule.name})
|
||||
end
|
||||
return nr
|
||||
end
|
||||
|
||||
function mesecon.rotate_rules_up(rules)
|
||||
local nr = {}
|
||||
for i, rule in ipairs(rules) do
|
||||
table.insert(nr, {
|
||||
x = rule.y,
|
||||
y = -rule.x,
|
||||
z = rule.z,
|
||||
name = rule.name})
|
||||
end
|
||||
return nr
|
||||
end
|
||||
|
||||
@ -1,14 +1,30 @@
|
||||
-- Un-forceload any forceloaded mapblocks from older versions of Mesecons which
|
||||
-- used forceloading instead of VoxelManipulators.
|
||||
local BLOCKSIZE = 16
|
||||
|
||||
-- convert block hash --> node position
|
||||
local function unhash_blockpos(hash)
|
||||
return vector.multiply(minetest.get_position_from_hash(hash), BLOCKSIZE)
|
||||
-- Ugly hack to prevent breaking compatibility with other mods
|
||||
-- Just remove the following two functions to delete the hack, to be done when other mods have updated
|
||||
function mesecon.receptor_on(self, pos, rules)
|
||||
if (self.receptor_on) then
|
||||
print("[Mesecons] Warning: A mod with mesecon support called mesecon:receptor_on.")
|
||||
print("[Mesecons] If you are the programmer of this mod, please update it ")
|
||||
print("[Mesecons] to use mesecon.receptor_on instead. mesecon:* is deprecated")
|
||||
print("[Mesecons] Otherwise, please make sure you're running the latest version")
|
||||
print("[Mesecons] of that mod and inform the mod creator.")
|
||||
else
|
||||
rules = pos
|
||||
pos = self
|
||||
end
|
||||
mesecon.queue:add_action(pos, "receptor_on", {rules}, nil, rules)
|
||||
end
|
||||
|
||||
local old_forceloaded_blocks = mesecon.file2table("mesecon_forceloaded")
|
||||
for hash, _ in pairs(old_forceloaded_blocks) do
|
||||
minetest.forceload_free_block(unhash_blockpos(hash))
|
||||
function mesecon.receptor_off(self, pos, rules)
|
||||
if (self.receptor_off) then
|
||||
print("[Mesecons] Warning: A mod with mesecon support called mesecon:receptor_off.")
|
||||
print("[Mesecons] If you are the programmer of this mod, please update it ")
|
||||
print("[Mesecons] to use mesecon.receptor_off instead. mesecon:* is deprecated")
|
||||
print("[Mesecons] Otherwise, please make sure you're running the latest version")
|
||||
print("[Mesecons] of that mod and inform the mod creator.")
|
||||
else
|
||||
rules = pos
|
||||
pos = self
|
||||
end
|
||||
mesecon.queue:add_action(pos, "receptor_off", {rules}, nil, rules)
|
||||
end
|
||||
os.remove(minetest.get_worldpath().."/mesecon_forceloaded")
|
||||
|
||||
|
||||
@ -1,3 +0,0 @@
|
||||
# textdomain: mesecons
|
||||
|
||||
Mesecons=Mesecons
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons
|
||||
|
||||
### oldwires.lua ###
|
||||
Mesecons=Mesekonduktilo
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons
|
||||
|
||||
### oldwires.lua ###
|
||||
Mesecons=Mesecons
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons
|
||||
|
||||
### oldwires.lua ###
|
||||
Mesecons=Мезеконы
|
||||
@ -1,5 +0,0 @@
|
||||
# textdomain: mesecons
|
||||
|
||||
### oldwires.lua ###
|
||||
Mesecons=Месекони
|
||||
Mod that implements a ton of items related to digital circuitry.=Мод, який реалізує масу елементів, пов’язаних із цифровою схемою.
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons
|
||||
|
||||
### oldwires.lua ###
|
||||
Mesecons=
|
||||
@ -1,4 +0,0 @@
|
||||
name = mesecons
|
||||
# default is an optional dependency as some mods may expect it as a transitory
|
||||
# dependency when they depend on mesecons.
|
||||
optional_depends = default
|
||||
@ -1,19 +1,17 @@
|
||||
local S = minetest.get_translator(minetest.get_current_modname())
|
||||
|
||||
minetest.register_node("mesecons:mesecon_off", {
|
||||
drawtype = "raillike",
|
||||
tiles = {"jeija_mesecon_off.png", "jeija_mesecon_curved_off.png", "jeija_mesecon_t_junction_off.png", "jeija_mesecon_crossing_off.png"},
|
||||
inventory_image = "jeija_mesecon_off.png",
|
||||
wield_image = "jeija_mesecon_off.png",
|
||||
paramtype = "light",
|
||||
is_ground_content = false,
|
||||
is_ground_content = true,
|
||||
walkable = false,
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
fixed = {-0.5, -0.5, -0.5, 0.5, -0.45, 0.5},
|
||||
},
|
||||
groups = {dig_immediate=3, mesecon=1, mesecon_conductor_craftable=1},
|
||||
description= S("Mesecons"),
|
||||
description="Mesecons",
|
||||
mesecons = {conductor={
|
||||
state = mesecon.state.off,
|
||||
onstate = "mesecons:mesecon_on"
|
||||
@ -24,7 +22,7 @@ minetest.register_node("mesecons:mesecon_on", {
|
||||
drawtype = "raillike",
|
||||
tiles = {"jeija_mesecon_on.png", "jeija_mesecon_curved_on.png", "jeija_mesecon_t_junction_on.png", "jeija_mesecon_crossing_on.png"},
|
||||
paramtype = "light",
|
||||
is_ground_content = false,
|
||||
is_ground_content = true,
|
||||
walkable = false,
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
@ -32,7 +30,7 @@ minetest.register_node("mesecons:mesecon_on", {
|
||||
},
|
||||
groups = {dig_immediate=3, not_in_creaive_inventory=1, mesecon=1},
|
||||
drop = "mesecons:mesecon_off 1",
|
||||
light_source = minetest.LIGHT_MAX-11,
|
||||
light_source = LIGHT_MAX-11,
|
||||
mesecons = {conductor={
|
||||
state = mesecon.state.on,
|
||||
offstate = "mesecons:mesecon_off"
|
||||
|
||||
@ -1,87 +1,46 @@
|
||||
mesecon.rules = {}
|
||||
mesecon.state = {}
|
||||
|
||||
mesecon.rules.default = {
|
||||
{x = 0, y = 0, z = -1},
|
||||
{x = 1, y = 0, z = 0},
|
||||
{x = -1, y = 0, z = 0},
|
||||
{x = 0, y = 0, z = 1},
|
||||
{x = 1, y = 1, z = 0},
|
||||
{x = 1, y = -1, z = 0},
|
||||
{x = -1, y = 1, z = 0},
|
||||
{x = -1, y = -1, z = 0},
|
||||
{x = 0, y = 1, z = 1},
|
||||
{x = 0, y = -1, z = 1},
|
||||
{x = 0, y = 1, z = -1},
|
||||
{x = 0, y = -1, z = -1},
|
||||
}
|
||||
mesecon.rules.default =
|
||||
{{x=0, y=0, z=-1},
|
||||
{x=1, y=0, z=0},
|
||||
{x=-1, y=0, z=0},
|
||||
{x=0, y=0, z=1},
|
||||
{x=1, y=1, z=0},
|
||||
{x=1, y=-1, z=0},
|
||||
{x=-1, y=1, z=0},
|
||||
{x=-1, y=-1, z=0},
|
||||
{x=0, y=1, z=1},
|
||||
{x=0, y=-1, z=1},
|
||||
{x=0, y=1, z=-1},
|
||||
{x=0, y=-1, z=-1}}
|
||||
|
||||
mesecon.rules.floor = mesecon.merge_rule_sets(mesecon.rules.default, {{x = 0, y = -1, z = 0}})
|
||||
mesecon.rules.pplate = mesecon.mergetable(mesecon.rules.default, {{x=0, y=-2, z=0}})
|
||||
|
||||
mesecon.rules.pplate = mesecon.merge_rule_sets(mesecon.rules.floor, {{x = 0, y = -2, z = 0}})
|
||||
mesecon.rules.buttonlike =
|
||||
{{x = 1, y = 0, z = 0},
|
||||
{x = 1, y = 1, z = 0},
|
||||
{x = 1, y =-1, z = 0},
|
||||
{x = 1, y =-1, z = 1},
|
||||
{x = 1, y =-1, z =-1},
|
||||
{x = 2, y = 0, z = 0}}
|
||||
|
||||
mesecon.rules.buttonlike = {
|
||||
{x = 1, y = 0, z = 0},
|
||||
{x = 1, y = 1, z = 0},
|
||||
{x = 1, y = -1, z = 0},
|
||||
{x = 1, y = -1, z = 1},
|
||||
{x = 1, y = -1, z = -1},
|
||||
{x = 2, y = 0, z = 0},
|
||||
}
|
||||
|
||||
mesecon.rules.flat = {
|
||||
{x = 1, y = 0, z = 0},
|
||||
{x = -1, y = 0, z = 0},
|
||||
{x = 0, y = 0, z = 1},
|
||||
{x = 0, y = 0, z = -1},
|
||||
}
|
||||
|
||||
mesecon.rules.alldirs = {
|
||||
{x = 1, y = 0, z = 0},
|
||||
{x = -1, y = 0, z = 0},
|
||||
{x = 0, y = 1, z = 0},
|
||||
{x = 0, y = -1, z = 0},
|
||||
{x = 0, y = 0, z = 1},
|
||||
{x = 0, y = 0, z = -1},
|
||||
}
|
||||
|
||||
local rules_wallmounted = {
|
||||
xp = mesecon.rotate_rules_down(mesecon.rules.floor),
|
||||
xn = mesecon.rotate_rules_up(mesecon.rules.floor),
|
||||
yp = mesecon.rotate_rules_up(mesecon.rotate_rules_up(mesecon.rules.floor)),
|
||||
yn = mesecon.rules.floor,
|
||||
zp = mesecon.rotate_rules_left(mesecon.rotate_rules_up(mesecon.rules.floor)),
|
||||
zn = mesecon.rotate_rules_right(mesecon.rotate_rules_up(mesecon.rules.floor)),
|
||||
}
|
||||
|
||||
local rules_buttonlike = {
|
||||
xp = mesecon.rules.buttonlike,
|
||||
xn = mesecon.rotate_rules_right(mesecon.rotate_rules_right(mesecon.rules.buttonlike)),
|
||||
yp = mesecon.rotate_rules_down(mesecon.rules.buttonlike),
|
||||
yn = mesecon.rotate_rules_up(mesecon.rules.buttonlike),
|
||||
zp = mesecon.rotate_rules_right(mesecon.rules.buttonlike),
|
||||
zn = mesecon.rotate_rules_left(mesecon.rules.buttonlike),
|
||||
}
|
||||
|
||||
local function rules_from_dir(ruleset, dir)
|
||||
if not dir then return {} end
|
||||
|
||||
if dir.x == 1 then return ruleset.xp end
|
||||
if dir.y == 1 then return ruleset.yp end
|
||||
if dir.z == 1 then return ruleset.zp end
|
||||
if dir.x == -1 then return ruleset.xn end
|
||||
if dir.y == -1 then return ruleset.yn end
|
||||
if dir.z == -1 then return ruleset.zn end
|
||||
end
|
||||
|
||||
mesecon.rules.wallmounted_get = function(node)
|
||||
local dir = minetest.wallmounted_to_dir(node.param2)
|
||||
return rules_from_dir(rules_wallmounted, dir)
|
||||
end
|
||||
mesecon.rules.flat =
|
||||
{{x = 1, y = 0, z = 0},
|
||||
{x =-1, y = 0, z = 0},
|
||||
{x = 0, y = 0, z = 1},
|
||||
{x = 0, y = 0, z =-1}}
|
||||
|
||||
mesecon.rules.buttonlike_get = function(node)
|
||||
local dir = minetest.facedir_to_dir(node.param2)
|
||||
return rules_from_dir(rules_buttonlike, dir)
|
||||
local rules = mesecon.rules.buttonlike
|
||||
if node.param2 == 2 then
|
||||
rules=mesecon.rotate_rules_left(rules)
|
||||
elseif node.param2 == 3 then
|
||||
rules=mesecon.rotate_rules_right(mesecon.rotate_rules_right(rules))
|
||||
elseif node.param2 == 0 then
|
||||
rules=mesecon.rotate_rules_right(rules)
|
||||
end
|
||||
return rules
|
||||
end
|
||||
|
||||
mesecon.state.on = "on"
|
||||
|
||||
@ -1,8 +1,7 @@
|
||||
-- Dig and place services
|
||||
|
||||
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.
|
||||
mesecon.on_placenode = function (pos, node)
|
||||
mesecon.update_autoconnect(pos, node)
|
||||
|
||||
-- Receptors: Send on signal when active
|
||||
if mesecon.is_receptor_on(node.name) then
|
||||
@ -12,33 +11,28 @@ 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 = {x = pos.x - s.x, y = pos.y - s.y, z = pos.z - s.z}
|
||||
mesecon.turnon(pos, rule)
|
||||
end
|
||||
mesecon.vm_commit()
|
||||
--mesecon.receptor_on (pos, mesecon.conductor_get_rules(node))
|
||||
elseif mesecon.is_conductor_on(node) then
|
||||
minetest.swap_node(pos, {name = mesecon.get_conductor_off(node)})
|
||||
end
|
||||
end
|
||||
|
||||
-- Effectors: Send changesignal and activate or deactivate
|
||||
if mesecon.is_effector(node.name) then
|
||||
local powered_rules = {}
|
||||
local unpowered_rules = {}
|
||||
|
||||
-- for each input rule, check if powered
|
||||
for _, r in ipairs(mesecon.effector_get_rules(node)) do
|
||||
local powered = mesecon.is_powered(pos, r)
|
||||
if powered then table.insert(powered_rules, r)
|
||||
else table.insert(unpowered_rules, r) end
|
||||
if powered then table.insert(powered_rules, r) end
|
||||
|
||||
local state = powered and mesecon.state.on or mesecon.state.off
|
||||
mesecon.changesignal(pos, node, r, state, 1)
|
||||
@ -48,92 +42,53 @@ mesecon.on_placenode = function(pos, node)
|
||||
for _, r in ipairs(powered_rules) do
|
||||
mesecon.activate(pos, node, r, 1)
|
||||
end
|
||||
else
|
||||
for _, r in ipairs(unpowered_rules) do
|
||||
mesecon.deactivate(pos, node, r, 1)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
mesecon.on_dignode = function(pos, node)
|
||||
mesecon.on_dignode = function (pos, node)
|
||||
if mesecon.is_conductor_on(node) then
|
||||
mesecon.receptor_off(pos, mesecon.conductor_get_rules(node))
|
||||
elseif mesecon.is_receptor_on(node.name) then
|
||||
mesecon.receptor_off(pos, mesecon.receptor_get_rules(node))
|
||||
end
|
||||
|
||||
mesecon.execute_autoconnect_hooks_queue(pos, node)
|
||||
mesecon.queue:add_action(pos, "update_autoconnect", {node})
|
||||
end
|
||||
|
||||
function mesecon.on_blastnode(pos)
|
||||
local node = minetest.get_node(pos)
|
||||
minetest.remove_node(pos)
|
||||
mesecon.on_dignode(pos, node)
|
||||
return minetest.get_node_drops(node.name, "")
|
||||
end
|
||||
mesecon.queue:add_function("update_autoconnect", mesecon.update_autoconnect)
|
||||
|
||||
minetest.register_on_placenode(mesecon.on_placenode)
|
||||
minetest.register_on_dignode(mesecon.on_dignode)
|
||||
|
||||
-- Overheating service for fast circuits
|
||||
local OVERHEAT_MAX = mesecon.setting("overheat_max", 20)
|
||||
local COOLDOWN_TIME = mesecon.setting("cooldown_time", 2.0)
|
||||
local COOLDOWN_STEP = mesecon.setting("cooldown_granularity", 0.5)
|
||||
local COOLDOWN_MULTIPLIER = OVERHEAT_MAX / COOLDOWN_TIME
|
||||
local cooldown_timer = 0.0
|
||||
local object_heat = {}
|
||||
|
||||
-- returns true if heat is too high
|
||||
function mesecon.do_overheat(pos)
|
||||
local id = minetest.hash_node_position(pos)
|
||||
local heat = (object_heat[id] or 0) + 1
|
||||
object_heat[id] = heat
|
||||
if heat >= OVERHEAT_MAX then
|
||||
minetest.log("action", "Node overheats at " .. minetest.pos_to_string(pos))
|
||||
object_heat[id] = nil
|
||||
mesecon.do_overheat = function(pos)
|
||||
local meta = minetest.get_meta(pos)
|
||||
local heat = meta:get_int("heat") or 0
|
||||
|
||||
heat = heat + 1
|
||||
meta:set_int("heat", heat)
|
||||
|
||||
if heat < mesecon.setting("overheat_max", 20) then
|
||||
mesecon.queue:add_action(pos, "cooldown", {}, 1, nil, 0)
|
||||
else
|
||||
return true
|
||||
end
|
||||
|
||||
return false
|
||||
end
|
||||
|
||||
function mesecon.do_cooldown(pos)
|
||||
local id = minetest.hash_node_position(pos)
|
||||
object_heat[id] = nil
|
||||
end
|
||||
|
||||
function mesecon.get_heat(pos)
|
||||
local id = minetest.hash_node_position(pos)
|
||||
return object_heat[id] or 0
|
||||
end
|
||||
mesecon.queue:add_function("cooldown", function (pos)
|
||||
if minetest.get_item_group(minetest.get_node(pos).name, "overheat") == 0 then
|
||||
return -- node has been moved, this one does not use overheating - ignore
|
||||
end
|
||||
|
||||
function mesecon.move_hot_nodes(moved_nodes)
|
||||
local new_heat = {}
|
||||
for _, n in ipairs(moved_nodes) do
|
||||
local old_id = minetest.hash_node_position(n.oldpos)
|
||||
local new_id = minetest.hash_node_position(n.pos)
|
||||
new_heat[new_id] = object_heat[old_id]
|
||||
object_heat[old_id] = nil
|
||||
end
|
||||
for id, heat in pairs(new_heat) do
|
||||
object_heat[id] = heat
|
||||
end
|
||||
end
|
||||
local meta = minetest.get_meta(pos)
|
||||
local heat = meta:get_int("heat")
|
||||
|
||||
local function global_cooldown(dtime)
|
||||
cooldown_timer = cooldown_timer + dtime
|
||||
if cooldown_timer < COOLDOWN_STEP then
|
||||
return -- don't overload the CPU
|
||||
if (heat > 0) then
|
||||
meta:set_int("heat", heat - 1)
|
||||
end
|
||||
local cooldown = COOLDOWN_MULTIPLIER * cooldown_timer
|
||||
cooldown_timer = 0
|
||||
for id, heat in pairs(object_heat) do
|
||||
heat = heat - cooldown
|
||||
if heat <= 0 then
|
||||
object_heat[id] = nil -- free some RAM
|
||||
else
|
||||
object_heat[id] = heat
|
||||
end
|
||||
end
|
||||
end
|
||||
minetest.register_globalstep(global_cooldown)
|
||||
end)
|
||||
|
||||
@ -1,15 +1,10 @@
|
||||
-- SETTINGS
|
||||
function mesecon.setting(setting, default)
|
||||
if type(default) == "boolean" then
|
||||
local read = minetest.settings:get_bool("mesecon."..setting)
|
||||
if read == nil then
|
||||
return default
|
||||
else
|
||||
return read
|
||||
end
|
||||
if type(default) == "bool" then
|
||||
return minetest.setting_getbool("mesecon."..setting) or default
|
||||
elseif type(default) == "string" then
|
||||
return minetest.settings:get("mesecon."..setting) or default
|
||||
return minetest.setting_get("mesecon."..setting) or default
|
||||
elseif type(default) == "number" then
|
||||
return tonumber(minetest.settings:get("mesecon."..setting) or default)
|
||||
return tonumber(minetest.setting_get("mesecon."..setting) or default)
|
||||
end
|
||||
end
|
||||
|
||||
@ -1,62 +0,0 @@
|
||||
require("mineunit")
|
||||
|
||||
fixture("mesecons")
|
||||
|
||||
describe("action queue", function()
|
||||
local layout = {
|
||||
{{x = 1, y = 0, z = 0}, "mesecons:test_receptor_off"},
|
||||
{{x = 0, y = 0, z = 0}, "mesecons:test_conductor_off"},
|
||||
{{x = -1, y = 0, z = 0}, "mesecons:test_conductor_off"},
|
||||
{{x = 0, y = 1, z = 0}, "mesecons:test_effector"},
|
||||
{{x = -1, y = 1, z = 0}, "mesecons:test_effector"},
|
||||
}
|
||||
|
||||
before_each(function()
|
||||
world.layout(layout)
|
||||
end)
|
||||
|
||||
after_each(function()
|
||||
mesecon._test_reset()
|
||||
world.clear()
|
||||
end)
|
||||
|
||||
it("executes in order", function()
|
||||
world.set_node(layout[1][1], "mesecons:test_receptor_on")
|
||||
mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
|
||||
mineunit:execute_globalstep() -- Execute receptor_on action
|
||||
mineunit:execute_globalstep() -- Execute activate/change actions
|
||||
assert.equal(2, #mesecon._test_effector_events)
|
||||
assert.same({"on", layout[4][1]}, mesecon._test_effector_events[1])
|
||||
assert.same({"on", layout[5][1]}, mesecon._test_effector_events[2])
|
||||
|
||||
world.set_node(layout[1][1], "mesecons:test_receptor_off")
|
||||
mesecon.receptor_off(layout[1][1], mesecon.rules.alldirs)
|
||||
mineunit:execute_globalstep() -- Execute receptor_off action
|
||||
mineunit:execute_globalstep() -- Execute deactivate/change actions
|
||||
assert.equal(4, #mesecon._test_effector_events)
|
||||
assert.same({"off", layout[4][1]}, mesecon._test_effector_events[3])
|
||||
assert.same({"off", layout[5][1]}, mesecon._test_effector_events[4])
|
||||
end)
|
||||
|
||||
it("discards outdated/overwritten node events", function()
|
||||
world.set_node(layout[1][1], "mesecons:test_receptor_on")
|
||||
mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
|
||||
world.set_node(layout[1][1], "mesecons:test_receptor_off")
|
||||
mesecon.receptor_off(layout[1][1], mesecon.rules.alldirs)
|
||||
mineunit:execute_globalstep() -- Execute receptor_off action
|
||||
mineunit:execute_globalstep() -- Execute deactivate/change actions
|
||||
assert.equal(0, #mesecon._test_effector_events)
|
||||
end)
|
||||
|
||||
it("delays actions", function()
|
||||
world.set_node(layout[1][1], "mesecons:test_receptor_on")
|
||||
mesecon.queue:add_action(layout[1][1], "receptor_on", {mesecon.rules.alldirs}, 1, nil)
|
||||
mineunit:execute_globalstep(0.1)
|
||||
mineunit:execute_globalstep(1)
|
||||
assert.equal(0, #mesecon._test_effector_events)
|
||||
mineunit:execute_globalstep() -- Execute receptor_on action
|
||||
assert.equal(0, #mesecon._test_effector_events)
|
||||
mineunit:execute_globalstep() -- Execute activate/change actions
|
||||
assert.equal(2, #mesecon._test_effector_events)
|
||||
end)
|
||||
end)
|
||||
@ -1 +0,0 @@
|
||||
fixture_paths = {"../.test_fixtures"}
|
||||
@ -1,192 +0,0 @@
|
||||
require("mineunit")
|
||||
|
||||
fixture("mesecons")
|
||||
fixture("screwdriver")
|
||||
|
||||
describe("placement/digging service", function()
|
||||
local layout = {
|
||||
{{x = 1, y = 0, z = 0}, "mesecons:test_receptor_on"},
|
||||
{{x = 0, y = 0, z = 0}, "mesecons:test_conductor_on"},
|
||||
{{x = -1, y = 0, z = 0}, "mesecons:test_conductor_on"},
|
||||
{{x = 0, y = 1, z = 0}, "mesecons:test_effector"},
|
||||
{{x = -2, y = 0, z = 0}, "mesecons:test_effector"},
|
||||
{{x = 2, y = 0, z = 0}, "mesecons:test_effector"},
|
||||
}
|
||||
|
||||
before_each(function()
|
||||
world.layout(layout)
|
||||
end)
|
||||
|
||||
after_each(function()
|
||||
mesecon._test_reset()
|
||||
world.clear()
|
||||
end)
|
||||
|
||||
it("updates components when a receptor changes", function()
|
||||
-- Dig then replace a receptor and check that the connected effectors changed.
|
||||
|
||||
mesecon._test_dig(layout[1][1])
|
||||
mineunit:execute_globalstep() -- Execute receptor_off action
|
||||
assert.equal("mesecons:test_conductor_off", world.get_node(layout[2][1]).name)
|
||||
mineunit:execute_globalstep() -- Execute deactivate/change actions
|
||||
assert.equal(3, #mesecon._test_effector_events)
|
||||
|
||||
mesecon._test_place(layout[1][1], "mesecons:test_receptor_on")
|
||||
mineunit:execute_globalstep() -- Execute receptor_on action
|
||||
assert.equal("mesecons:test_conductor_on", world.get_node(layout[2][1]).name)
|
||||
mineunit:execute_globalstep() -- Execute activate/change action
|
||||
assert.equal(6, #mesecon._test_effector_events)
|
||||
end)
|
||||
|
||||
it("updates components when a conductor changes", function()
|
||||
-- Dig then replace a powered conductor and check that the connected effectors changed.
|
||||
|
||||
mesecon._test_dig(layout[2][1])
|
||||
mineunit:execute_globalstep() -- Execute receptor_off action
|
||||
assert.equal("mesecons:test_conductor_off", world.get_node(layout[3][1]).name)
|
||||
mineunit:execute_globalstep() -- Execute deactivate/change actions
|
||||
assert.equal(2, #mesecon._test_effector_events)
|
||||
|
||||
mesecon._test_place(layout[2][1], "mesecons:test_conductor_off")
|
||||
assert.equal("mesecons:test_conductor_on", world.get_node(layout[2][1]).name)
|
||||
assert.equal("mesecons:test_conductor_on", world.get_node(layout[3][1]).name)
|
||||
mineunit:execute_globalstep() -- Execute activate/change actions
|
||||
assert.equal(4, #mesecon._test_effector_events)
|
||||
end)
|
||||
|
||||
it("updates effectors on placement", function()
|
||||
local pos = {x = 0, y = 0, z = 1}
|
||||
mesecon._test_place(pos, "mesecons:test_effector")
|
||||
mineunit:execute_globalstep() -- Execute activate/change actions
|
||||
assert.equal(tonumber("10100000", 2), world.get_node(pos).param2)
|
||||
end)
|
||||
|
||||
it("updates multiconductors on placement", function()
|
||||
local pos = {x = 0, y = 0, z = 1}
|
||||
mesecon._test_place(pos, "mesecons:test_multiconductor_off")
|
||||
assert.equal("mesecons:test_multiconductor_010", world.get_node(pos).name)
|
||||
end)
|
||||
|
||||
it("turns off conductors on placement", function()
|
||||
local pos = {x = 3, y = 0, z = 0}
|
||||
mesecon._test_place(pos, "mesecons:test_conductor_on")
|
||||
assert.equal("mesecons:test_conductor_off", world.get_node(pos).name)
|
||||
end)
|
||||
|
||||
it("turns off multiconductors on placement", function()
|
||||
local pos = {x = 3, y = 0, z = 0}
|
||||
mesecon._test_place(pos, "mesecons:test_multiconductor_on")
|
||||
assert.equal("mesecons:test_multiconductor_off", world.get_node(pos).name)
|
||||
end)
|
||||
|
||||
it("triggers autoconnect hooks", function()
|
||||
mesecon._test_dig(layout[2][1])
|
||||
mineunit:execute_globalstep() -- Execute delayed hook
|
||||
assert.equal(1, #mesecon._test_autoconnects)
|
||||
|
||||
mesecon._test_place(layout[2][1], layout[2][2])
|
||||
assert.equal(2, #mesecon._test_autoconnects)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe("overheating service", function()
|
||||
local layout = {
|
||||
{{x = 0, y = 0, z = 0}, "mesecons:test_receptor_off"},
|
||||
{{x = 1, y = 0, z = 0}, "mesecons:test_effector"},
|
||||
{{x = 2, y = 0, z = 0}, "mesecons:test_receptor_on"},
|
||||
}
|
||||
|
||||
before_each(function()
|
||||
world.layout(layout)
|
||||
end)
|
||||
|
||||
after_each(function()
|
||||
mesecon._test_reset()
|
||||
world.clear()
|
||||
end)
|
||||
|
||||
it("tracks heat", function()
|
||||
mesecon.do_overheat(layout[2][1])
|
||||
assert.equal(1, mesecon.get_heat(layout[2][1]))
|
||||
mesecon.do_cooldown(layout[2][1])
|
||||
assert.equal(0, mesecon.get_heat(layout[2][1]))
|
||||
end)
|
||||
|
||||
it("cools over time", function()
|
||||
mesecon.do_overheat(layout[2][1])
|
||||
assert.equal(1, mesecon.get_heat(layout[2][1]))
|
||||
mineunit:execute_globalstep(60)
|
||||
mineunit:execute_globalstep(60)
|
||||
mineunit:execute_globalstep(60)
|
||||
assert.equal(0, mesecon.get_heat(layout[2][1]))
|
||||
end)
|
||||
|
||||
it("tracks movement", function()
|
||||
local oldpos = layout[2][1]
|
||||
local pos = vector.offset(oldpos, 0, 1, 0)
|
||||
mesecon.do_overheat(oldpos)
|
||||
mesecon.move_hot_nodes({{pos = pos, oldpos = oldpos}})
|
||||
assert.equal(0, mesecon.get_heat(oldpos))
|
||||
assert.equal(1, mesecon.get_heat(pos))
|
||||
end)
|
||||
|
||||
it("causes overheating", function()
|
||||
-- Switch the first receptor on and off until it overheats/breaks a receptor.
|
||||
repeat
|
||||
if mesecon.flipstate(layout[1][1], minetest.get_node(layout[1][1])) == "on" then
|
||||
mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
|
||||
else
|
||||
mesecon.receptor_off(layout[1][1], mesecon.rules.alldirs)
|
||||
end
|
||||
mineunit:execute_globalstep(0) -- Execute receptor_on/receptor_off/activate/deactivate/change actions
|
||||
until minetest.get_node(layout[2][1]).name ~= "mesecons:test_effector"
|
||||
assert.same({"overheat", layout[2][1]}, mesecon._test_effector_events[#mesecon._test_effector_events])
|
||||
assert.equal(0, mesecon.get_heat(layout[2][1]))
|
||||
end)
|
||||
end)
|
||||
|
||||
describe("screwdriver service", function()
|
||||
local layout = {
|
||||
{{x = 0, y = 0, z = 0}, "mesecons:test_conductor_rot_on"},
|
||||
{{x = 1, y = 0, z = 0}, "mesecons:test_receptor_on"},
|
||||
{{x = -1, y = 0, z = 0}, "mesecons:test_conductor_on"},
|
||||
{{x = 0, y = 0, z = 1}, "mesecons:test_receptor_on"},
|
||||
{{x = 0, y = 0, z = -1}, "mesecons:test_conductor_off"},
|
||||
}
|
||||
|
||||
local function rotate(new_param2)
|
||||
local pos = layout[1][1]
|
||||
local node = world.get_node(pos)
|
||||
local on_rotate = minetest.registered_nodes[node.name].on_rotate
|
||||
on_rotate(pos, node, nil, screwdriver.ROTATE_FACE, new_param2)
|
||||
end
|
||||
|
||||
before_each(function()
|
||||
world.layout(layout)
|
||||
end)
|
||||
|
||||
after_each(function()
|
||||
mesecon._test_reset()
|
||||
world.clear()
|
||||
end)
|
||||
|
||||
it("updates conductors", function()
|
||||
-- Rotate a conductor and see that the circuit state changes.
|
||||
rotate(1)
|
||||
mineunit:execute_globalstep() -- Execute receptor_off action
|
||||
assert.equal("mesecons:test_conductor_off", world.get_node(layout[3][1]).name)
|
||||
assert.equal("mesecons:test_conductor_on", world.get_node(layout[5][1]).name)
|
||||
rotate(2)
|
||||
mineunit:execute_globalstep() -- Execute receptor_off action
|
||||
assert.equal("mesecons:test_conductor_on", world.get_node(layout[3][1]).name)
|
||||
assert.equal("mesecons:test_conductor_off", world.get_node(layout[5][1]).name)
|
||||
rotate(3)
|
||||
mineunit:execute_globalstep() -- Execute receptor_off action
|
||||
assert.equal("mesecons:test_conductor_off", world.get_node(layout[3][1]).name)
|
||||
assert.equal("mesecons:test_conductor_on", world.get_node(layout[5][1]).name)
|
||||
rotate(0)
|
||||
mineunit:execute_globalstep() -- Execute receptor_off action
|
||||
assert.equal("mesecons:test_conductor_on", world.get_node(layout[3][1]).name)
|
||||
assert.equal("mesecons:test_conductor_off", world.get_node(layout[5][1]).name)
|
||||
end)
|
||||
end)
|
||||
@ -1,147 +0,0 @@
|
||||
require("mineunit")
|
||||
|
||||
fixture("mesecons")
|
||||
|
||||
describe("state", function()
|
||||
local layout = {
|
||||
{{x = 1, y = 0, z = 0}, "mesecons:test_receptor_off"},
|
||||
{{x = 0, y = 1, z = 0}, "mesecons:test_receptor_off"},
|
||||
{{x = 0, y = 0, z = 0}, "mesecons:test_conductor_off"},
|
||||
{{x = -1, y = 0, z = 0}, "mesecons:test_effector"},
|
||||
{{x = 2, y = 0, z = 0}, "mesecons:test_effector"},
|
||||
{{x = 0, y = -1, z = 0}, "mesecons:test_effector"},
|
||||
}
|
||||
|
||||
before_each(function()
|
||||
world.layout(layout)
|
||||
end)
|
||||
|
||||
after_each(function()
|
||||
mesecon._test_reset()
|
||||
world.clear()
|
||||
end)
|
||||
|
||||
it("turns on", function()
|
||||
world.set_node(layout[1][1], "mesecons:test_receptor_on")
|
||||
mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
|
||||
mineunit:execute_globalstep() -- Execute receptor_on action
|
||||
mineunit:execute_globalstep() -- Execute activate/change actions
|
||||
assert.equal("mesecons:test_conductor_on", world.get_node(layout[3][1]).name)
|
||||
assert.equal(tonumber("10000001", 2), world.get_node(layout[4][1]).param2)
|
||||
assert.equal(tonumber("10000010", 2), world.get_node(layout[5][1]).param2)
|
||||
assert.equal(tonumber("10000100", 2), world.get_node(layout[6][1]).param2)
|
||||
|
||||
world.set_node(layout[2][1], "mesecons:test_receptor_on")
|
||||
mesecon.receptor_on(layout[2][1], mesecon.rules.alldirs)
|
||||
mineunit:execute_globalstep() -- Execute receptor_on action
|
||||
mineunit:execute_globalstep() -- Execute activate/change actions
|
||||
assert.equal("mesecons:test_conductor_on", world.get_node(layout[3][1]).name)
|
||||
assert.equal(tonumber("10000001", 2), world.get_node(layout[4][1]).param2)
|
||||
assert.equal(tonumber("10000010", 2), world.get_node(layout[5][1]).param2)
|
||||
assert.equal(tonumber("10000100", 2), world.get_node(layout[6][1]).param2)
|
||||
end)
|
||||
|
||||
it("turns off", function()
|
||||
world.set_node(layout[1][1], "mesecons:test_receptor_on")
|
||||
world.set_node(layout[2][1], "mesecons:test_receptor_on")
|
||||
mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
|
||||
mesecon.receptor_on(layout[2][1], mesecon.rules.alldirs)
|
||||
mineunit:execute_globalstep() -- Execute receptor_on actions
|
||||
|
||||
world.set_node(layout[1][1], "mesecons:test_receptor_off")
|
||||
mesecon.receptor_off(layout[1][1], mesecon.rules.alldirs)
|
||||
mineunit:execute_globalstep() -- Execute receptor_off and activate/change actions
|
||||
mineunit:execute_globalstep() -- Execute deactivate/change actions
|
||||
assert.equal("mesecons:test_conductor_on", world.get_node(layout[3][1]).name)
|
||||
assert.equal(tonumber("10000001", 2), world.get_node(layout[4][1]).param2)
|
||||
assert.equal(tonumber("00000000", 2), world.get_node(layout[5][1]).param2)
|
||||
assert.equal(tonumber("10000100", 2), world.get_node(layout[6][1]).param2)
|
||||
|
||||
world.set_node(layout[2][1], "mesecons:test_receptor_off")
|
||||
mesecon.receptor_off(layout[2][1], mesecon.rules.alldirs)
|
||||
mineunit:execute_globalstep() -- Execute receptor_off action
|
||||
mineunit:execute_globalstep() -- Execute deactivate/change actions
|
||||
assert.equal("mesecons:test_conductor_off", world.get_node(layout[3][1]).name)
|
||||
assert.equal(tonumber("00000000", 2), world.get_node(layout[4][1]).param2)
|
||||
assert.equal(tonumber("00000000", 2), world.get_node(layout[5][1]).param2)
|
||||
assert.equal(tonumber("00000000", 2), world.get_node(layout[6][1]).param2)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe("rotation", function()
|
||||
local layout = {
|
||||
{{x = 0, y = 0, z = 0}, "mesecons:test_receptor_off"},
|
||||
{{x = 1, y = 0, z = 0}, {name = "mesecons:test_conductor_rot_off", param2 = 0}},
|
||||
{{x = 0, y = 0, z = 1}, {name = "mesecons:test_conductor_rot_off", param2 = 1}},
|
||||
{{x = -1, y = 0, z = 0}, {name = "mesecons:test_conductor_rot_off", param2 = 2}},
|
||||
{{x = 0, y = 0, z = -1}, {name = "mesecons:test_conductor_rot_off", param2 = 3}},
|
||||
}
|
||||
|
||||
before_each(function()
|
||||
for _, entry in ipairs(layout) do
|
||||
world.set_node(entry[1], entry[2])
|
||||
end
|
||||
end)
|
||||
|
||||
after_each(function()
|
||||
mesecon._test_reset()
|
||||
world.clear()
|
||||
end)
|
||||
|
||||
it("works", function()
|
||||
world.set_node(layout[1][1], "mesecons:test_receptor_on")
|
||||
mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
|
||||
mineunit:execute_globalstep() -- Execute receptor_on action
|
||||
assert.equal("mesecons:test_conductor_rot_on", world.get_node(layout[2][1]).name)
|
||||
assert.equal("mesecons:test_conductor_rot_on", world.get_node(layout[3][1]).name)
|
||||
assert.equal("mesecons:test_conductor_rot_on", world.get_node(layout[4][1]).name)
|
||||
assert.equal("mesecons:test_conductor_rot_on", world.get_node(layout[5][1]).name)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe("multiconductor", function()
|
||||
local layout = {
|
||||
{{x = 1, y = 0, z = 0}, "mesecons:test_receptor_off"},
|
||||
{{x = 0, y = 1, z = 0}, "mesecons:test_receptor_off"},
|
||||
{{x = 0, y = 0, z = 1}, "mesecons:test_receptor_off"},
|
||||
{{x = 0, y = 0, z = 0}, "mesecons:test_multiconductor_off"},
|
||||
}
|
||||
|
||||
before_each(function()
|
||||
world.layout(layout)
|
||||
end)
|
||||
|
||||
after_each(function()
|
||||
world.clear()
|
||||
mesecon._test_reset()
|
||||
end)
|
||||
|
||||
it("separates its subparts", function()
|
||||
world.set_node(layout[1][1], "mesecons:test_receptor_on")
|
||||
mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
|
||||
mineunit:execute_globalstep() -- Execute receptor_on action
|
||||
assert.equal("mesecons:test_multiconductor_001", world.get_node(layout[4][1]).name)
|
||||
|
||||
world.set_node(layout[2][1], "mesecons:test_receptor_on")
|
||||
mesecon.receptor_on(layout[2][1], mesecon.rules.alldirs)
|
||||
mineunit:execute_globalstep() -- Execute receptor_on action
|
||||
assert.equal("mesecons:test_multiconductor_011", world.get_node(layout[4][1]).name)
|
||||
|
||||
world.set_node(layout[3][1], "mesecons:test_receptor_on")
|
||||
mesecon.receptor_on(layout[3][1], mesecon.rules.alldirs)
|
||||
mineunit:execute_globalstep() -- Execute receptor_on action
|
||||
assert.equal("mesecons:test_multiconductor_on", world.get_node(layout[4][1]).name)
|
||||
end)
|
||||
|
||||
it("loops through itself", function()
|
||||
-- Make a loop.
|
||||
world.set_node({x = 0, y = -1, z = 0}, "mesecons:test_conductor_off")
|
||||
world.set_node({x = -1, y = -1, z = 0}, "mesecons:test_conductor_off")
|
||||
world.set_node({x = -1, y = 0, z = 0}, "mesecons:test_conductor_off")
|
||||
|
||||
world.set_node(layout[1][1], "mesecons:test_receptor_on")
|
||||
mesecon.receptor_on(layout[1][1], mesecon.rules.alldirs)
|
||||
mineunit:execute_globalstep() -- Execute receptor_on action
|
||||
assert.equal("mesecons:test_multiconductor_101", world.get_node(layout[4][1]).name)
|
||||
end)
|
||||
end)
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 191 B |
BIN
mesecons/textures/jeija_fiber.png
Normal file
BIN
mesecons/textures/jeija_fiber.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 592 B |
BIN
mesecons/textures/jeija_glue.png
Normal file
BIN
mesecons/textures/jeija_glue.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 487 B |
Binary file not shown.
|
Before Width: | Height: | Size: 844 B |
Binary file not shown.
|
Before Width: | Height: | Size: 838 B |
Binary file not shown.
|
Before Width: | Height: | Size: 851 B |
Binary file not shown.
|
Before Width: | Height: | Size: 846 B |
BIN
mesecons/textures/jeija_mesecon_switch_off.png
Normal file
BIN
mesecons/textures/jeija_mesecon_switch_off.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 598 B |
BIN
mesecons/textures/jeija_mesecon_switch_on.png
Normal file
BIN
mesecons/textures/jeija_mesecon_switch_on.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 692 B |
BIN
mesecons/textures/jeija_mesecon_switch_side.png
Normal file
BIN
mesecons/textures/jeija_mesecon_switch_side.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 553 B |
Binary file not shown.
|
Before Width: | Height: | Size: 222 B |
Binary file not shown.
|
Before Width: | Height: | Size: 504 B |
BIN
mesecons/textures/jeija_silicon.png
Normal file
BIN
mesecons/textures/jeija_silicon.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 867 B |
Binary file not shown.
|
Before Width: | Height: | Size: 144 B After Width: | Height: | Size: 204 B |
Binary file not shown.
|
Before Width: | Height: | Size: 377 B After Width: | Height: | Size: 465 B |
Binary file not shown.
|
Before Width: | Height: | Size: 362 B After Width: | Height: | Size: 464 B |
@ -2,99 +2,10 @@ function mesecon.move_node(pos, newpos)
|
||||
local node = minetest.get_node(pos)
|
||||
local meta = minetest.get_meta(pos):to_table()
|
||||
minetest.remove_node(pos)
|
||||
minetest.set_node(newpos, node)
|
||||
minetest.add_node(newpos, node)
|
||||
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 = {}
|
||||
for i, rule in ipairs(rules) do
|
||||
table.insert(nr, {
|
||||
x = -rule.z,
|
||||
y = rule.y,
|
||||
z = rule.x,
|
||||
name = rule.name})
|
||||
end
|
||||
return nr
|
||||
end
|
||||
|
||||
function mesecon.rotate_rules_left(rules)
|
||||
local nr = {}
|
||||
for i, rule in ipairs(rules) do
|
||||
table.insert(nr, {
|
||||
x = rule.z,
|
||||
y = rule.y,
|
||||
z = -rule.x,
|
||||
name = rule.name})
|
||||
end
|
||||
return nr
|
||||
end
|
||||
|
||||
function mesecon.rotate_rules_down(rules)
|
||||
local nr = {}
|
||||
for i, rule in ipairs(rules) do
|
||||
table.insert(nr, {
|
||||
x = -rule.y,
|
||||
y = rule.x,
|
||||
z = rule.z,
|
||||
name = rule.name})
|
||||
end
|
||||
return nr
|
||||
end
|
||||
|
||||
function mesecon.rotate_rules_up(rules)
|
||||
local nr = {}
|
||||
for i, rule in ipairs(rules) do
|
||||
table.insert(nr, {
|
||||
x = rule.y,
|
||||
y = -rule.x,
|
||||
z = rule.z,
|
||||
name = rule.name})
|
||||
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)
|
||||
--[[
|
||||
{
|
||||
@ -139,7 +50,7 @@ function mesecon.rule2bit(findrule, allrules)
|
||||
end
|
||||
for m,metarule in ipairs( allrules) do
|
||||
for _, rule in ipairs(metarule ) do
|
||||
if vector.equals(findrule, rule) then
|
||||
if mesecon.cmpPos(findrule, rule) then
|
||||
return m
|
||||
end
|
||||
end
|
||||
@ -158,7 +69,7 @@ function mesecon.rule2metaindex(findrule, allrules)
|
||||
|
||||
for m, metarule in ipairs( allrules) do
|
||||
for _, rule in ipairs(metarule ) do
|
||||
if vector.equals(findrule, rule) then
|
||||
if mesecon.cmpPos(findrule, rule) then
|
||||
return m
|
||||
end
|
||||
end
|
||||
@ -203,9 +114,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
|
||||
|
||||
@ -224,39 +133,45 @@ function mesecon.set_bit(binary,bit,value)
|
||||
end
|
||||
|
||||
function mesecon.invertRule(r)
|
||||
return vector.multiply(r, -1)
|
||||
return {x = -r.x, y = -r.y, z = -r.z}
|
||||
end
|
||||
|
||||
function mesecon.tablecopy(obj) -- deep copy
|
||||
if type(obj) == "table" then
|
||||
return table.copy(obj)
|
||||
function mesecon.addPosRule(p, r)
|
||||
return {x = p.x + r.x, y = p.y + r.y, z = p.z + r.z}
|
||||
end
|
||||
|
||||
function mesecon.cmpPos(p1, p2)
|
||||
return (p1.x == p2.x and p1.y == p2.y and p1.z == p2.z)
|
||||
end
|
||||
|
||||
function mesecon.tablecopy(table) -- deep table copy
|
||||
if type(table) ~= "table" then return table end -- no need to copy
|
||||
local newtable = {}
|
||||
|
||||
for idx, item in pairs(table) do
|
||||
if type(item) == "table" then
|
||||
newtable[idx] = mesecon.tablecopy(item)
|
||||
else
|
||||
newtable[idx] = item
|
||||
end
|
||||
end
|
||||
return obj
|
||||
|
||||
return newtable
|
||||
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,41 +184,14 @@ 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
|
||||
spec_common.__mesecon_basename = name
|
||||
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)
|
||||
@ -321,203 +209,3 @@ function mesecon.flipstate(pos, node)
|
||||
|
||||
return newstate
|
||||
end
|
||||
|
||||
-- File writing / reading utilities
|
||||
local wpath = minetest.get_worldpath()
|
||||
function mesecon.file2table(filename)
|
||||
local f = io.open(wpath.."/"..filename, "r")
|
||||
if f == nil then return {} end
|
||||
local t = f:read("*all")
|
||||
f:close()
|
||||
if t == "" or t == nil then return {} end
|
||||
return minetest.deserialize(t)
|
||||
end
|
||||
|
||||
function mesecon.table2file(filename, table)
|
||||
local f = io.open(wpath.."/"..filename, "w")
|
||||
f:write(minetest.serialize(table))
|
||||
f:close()
|
||||
end
|
||||
|
||||
-- Block position "hashing" (convert to integer) functions for voxelmanip cache
|
||||
local BLOCKSIZE = 16
|
||||
|
||||
-- convert node position --> block hash
|
||||
local function hash_blockpos(pos)
|
||||
return minetest.hash_node_position({
|
||||
x = math.floor(pos.x/BLOCKSIZE),
|
||||
y = math.floor(pos.y/BLOCKSIZE),
|
||||
z = math.floor(pos.z/BLOCKSIZE)
|
||||
})
|
||||
end
|
||||
|
||||
-- Maps from a hashed mapblock position (as returned by hash_blockpos) to a
|
||||
-- table.
|
||||
--
|
||||
-- Contents of the table are:
|
||||
-- “vm” → the VoxelManipulator
|
||||
-- “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
|
||||
-- cached copy of the world loaded via VoxelManipulators. That cache can later
|
||||
-- be committed to the real map by means of vm_commit or discarded by means of
|
||||
-- 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
|
||||
-- and writing back any modified areas.
|
||||
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: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.
|
||||
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}
|
||||
vm_cache[hash] = tbl
|
||||
end
|
||||
return tbl
|
||||
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
|
||||
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
|
||||
|
||||
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)
|
||||
tbl.dirty = true
|
||||
end
|
||||
|
||||
-- Gets the node at a given position, regardless of whether it is loaded or
|
||||
-- not, respecting a transaction if one is in progress.
|
||||
--
|
||||
-- Outside a VM transaction, if the mapblock is not loaded, it is pulled into
|
||||
-- the server’s main map data cache and then accessed from there.
|
||||
--
|
||||
-- Inside a VM transaction, the transaction’s VM cache is used.
|
||||
function mesecon.get_node_force(pos)
|
||||
if vm_cache then
|
||||
return mesecon.vm_get_node(pos)
|
||||
else
|
||||
local node = minetest.get_node_or_nil(pos)
|
||||
if node == nil then
|
||||
-- Node is not currently loaded; use a VoxelManipulator to prime
|
||||
-- the mapblock cache and try again.
|
||||
minetest.get_voxel_manip(pos, pos)
|
||||
node = minetest.get_node_or_nil(pos)
|
||||
end
|
||||
return node
|
||||
end
|
||||
end
|
||||
|
||||
-- Swaps the node at a given position, regardless of whether it is loaded or
|
||||
-- not, respecting a transaction if one is in progress.
|
||||
--
|
||||
-- Outside a VM transaction, if the mapblock is not loaded, it is pulled into
|
||||
-- the server’s main map data cache and then accessed from there.
|
||||
--
|
||||
-- Inside a VM transaction, the transaction’s VM cache is used.
|
||||
--
|
||||
-- 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)
|
||||
if vm_cache then
|
||||
return mesecon.vm_swap_node(pos, name, update_light)
|
||||
else
|
||||
-- This serves to both ensure the mapblock is loaded and also hand us
|
||||
-- the old node table so we can preserve param2.
|
||||
local node = mesecon.get_node_force(pos)
|
||||
node.name = name
|
||||
minetest.swap_node(pos, node)
|
||||
end
|
||||
end
|
||||
|
||||
-- Autoconnect Hooks
|
||||
-- Nodes like conductors may change their appearance and their connection rules
|
||||
-- right after being placed or after being dug, e.g. the default wires use this
|
||||
-- to automatically connect to linking nodes after placement.
|
||||
-- After placement, the update function will be executed immediately so that the
|
||||
-- possibly changed rules can be taken into account when recalculating the circuit.
|
||||
-- After digging, the update function will be queued and executed after
|
||||
-- recalculating the circuit. The update function must take care of updating the
|
||||
-- node at the given position itself, but also all of the other nodes the given
|
||||
-- position may have (had) a linking connection to.
|
||||
mesecon.autoconnect_hooks = {}
|
||||
|
||||
-- name: A unique name for the hook, e.g. "foowire". Used to name the actionqueue function.
|
||||
-- fct: The update function with parameters function(pos, node)
|
||||
function mesecon.register_autoconnect_hook(name, fct)
|
||||
mesecon.autoconnect_hooks[name] = fct
|
||||
mesecon.queue:add_function("autoconnect_hook_"..name, fct)
|
||||
end
|
||||
|
||||
function mesecon.execute_autoconnect_hooks_now(pos, node)
|
||||
for _, fct in pairs(mesecon.autoconnect_hooks) do
|
||||
fct(pos, node)
|
||||
end
|
||||
end
|
||||
|
||||
function mesecon.execute_autoconnect_hooks_queue(pos, node)
|
||||
for name in pairs(mesecon.autoconnect_hooks) do
|
||||
mesecon.queue:add_action(pos, "autoconnect_hook_"..name, {node})
|
||||
end
|
||||
end
|
||||
|
||||
@ -8,23 +8,21 @@
|
||||
-- ## Update wire looks ##
|
||||
-- #######################
|
||||
|
||||
local S = minetest.get_translator(minetest.get_current_modname())
|
||||
|
||||
-- self_pos = pos of any mesecon node, from_pos = pos of conductor to getconnect for
|
||||
local wire_getconnect = function (from_pos, self_pos)
|
||||
local node = minetest.get_node(self_pos)
|
||||
local def = minetest.registered_nodes[node.name]
|
||||
if def and def.mesecons then
|
||||
if minetest.registered_nodes[node.name]
|
||||
and minetest.registered_nodes[node.name].mesecons then
|
||||
-- rules of node to possibly connect to
|
||||
local rules
|
||||
if def.mesecon_wire then
|
||||
local rules = {}
|
||||
if (minetest.registered_nodes[node.name].mesecon_wire) then
|
||||
rules = mesecon.rules.default
|
||||
else
|
||||
rules = mesecon.get_any_rules(node)
|
||||
end
|
||||
|
||||
for _, r in ipairs(mesecon.flattenrules(rules)) do
|
||||
if (vector.equals(vector.add(self_pos, r), from_pos)) then
|
||||
if (mesecon.cmpPos(mesecon.addPosRule(self_pos, r), from_pos)) then
|
||||
return true
|
||||
end
|
||||
end
|
||||
@ -37,7 +35,7 @@ local wire_updateconnect = function (pos)
|
||||
local connections = {}
|
||||
|
||||
for _, r in ipairs(mesecon.rules.default) do
|
||||
if wire_getconnect(pos, vector.add(pos, r)) then
|
||||
if wire_getconnect(pos, mesecon.addPosRule(pos, r)) then
|
||||
table.insert(connections, r)
|
||||
end
|
||||
end
|
||||
@ -68,18 +66,16 @@ end
|
||||
|
||||
local update_on_place_dig = function (pos, node)
|
||||
-- Update placed node (get_node again as it may have been dug)
|
||||
do
|
||||
local nn = minetest.get_node(pos)
|
||||
local def = minetest.registered_nodes[nn.name]
|
||||
if def and def.mesecon_wire then
|
||||
wire_updateconnect(pos)
|
||||
end
|
||||
local nn = minetest.get_node(pos)
|
||||
if (minetest.registered_nodes[nn.name])
|
||||
and (minetest.registered_nodes[nn.name].mesecon_wire) then
|
||||
wire_updateconnect(pos)
|
||||
end
|
||||
|
||||
-- Update nodes around it
|
||||
local rules
|
||||
local ndef = minetest.registered_nodes[node.name]
|
||||
if ndef and ndef.mesecon_wire then
|
||||
local rules = {}
|
||||
if minetest.registered_nodes[node.name]
|
||||
and minetest.registered_nodes[node.name].mesecon_wire then
|
||||
rules = mesecon.rules.default
|
||||
else
|
||||
rules = mesecon.get_any_rules(node)
|
||||
@ -87,15 +83,18 @@ local update_on_place_dig = function (pos, node)
|
||||
if (not rules) then return end
|
||||
|
||||
for _, r in ipairs(mesecon.flattenrules(rules)) do
|
||||
local np = vector.add(pos, r)
|
||||
local rdef = minetest.registered_nodes[minetest.get_node(np).name]
|
||||
if rdef and rdef.mesecon_wire then
|
||||
local np = mesecon.addPosRule(pos, r)
|
||||
if minetest.registered_nodes[minetest.get_node(np).name]
|
||||
and minetest.registered_nodes[minetest.get_node(np).name].mesecon_wire then
|
||||
wire_updateconnect(np)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
mesecon.register_autoconnect_hook("wire", update_on_place_dig)
|
||||
function mesecon.update_autoconnect(pos, node)
|
||||
if (not node) then node = minetest.get_node(pos) end
|
||||
update_on_place_dig(pos, node)
|
||||
end
|
||||
|
||||
-- ############################
|
||||
-- ## Wire node registration ##
|
||||
@ -144,7 +143,7 @@ nid_inc = function (nid)
|
||||
return i <= 8
|
||||
end
|
||||
|
||||
local function register_wires()
|
||||
register_wires = function()
|
||||
local nid = {}
|
||||
while true do
|
||||
-- Create group specifiction and nodeid string (see note above for details)
|
||||
@ -199,29 +198,25 @@ local function register_wires()
|
||||
}}
|
||||
|
||||
local groups_on = {dig_immediate = 3, mesecon_conductor_craftable = 1,
|
||||
not_in_creative_inventory = 1, not_in_craft_guide = 1}
|
||||
not_in_creative_inventory = 1}
|
||||
local groups_off = {dig_immediate = 3, mesecon_conductor_craftable = 1}
|
||||
if nodeid ~= "00000000" then
|
||||
groups_off["not_in_creative_inventory"] = 1
|
||||
groups_off["not_in_craft_guide"] = 1
|
||||
end
|
||||
|
||||
mesecon.register_node(":mesecons:wire_"..nodeid, {
|
||||
description = S("Mesecon"),
|
||||
mesecon.register_node("mesecons:wire_"..nodeid, {
|
||||
description = "Mesecon",
|
||||
drawtype = "nodebox",
|
||||
inventory_image = "mesecons_wire_inv.png",
|
||||
wield_image = "mesecons_wire_inv.png",
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
is_ground_content = false,
|
||||
sunlight_propagates = true,
|
||||
selection_box = selectionbox,
|
||||
node_box = nodebox,
|
||||
walkable = false,
|
||||
drop = "mesecons:wire_00000000_off",
|
||||
mesecon_wire = true,
|
||||
sounds = mesecon.node_sound.default,
|
||||
on_rotate = false,
|
||||
mesecon_wire = true
|
||||
}, {tiles = tiles_off, mesecons = meseconspec_off, groups = groups_off},
|
||||
{tiles = tiles_on, mesecons = meseconspec_on, groups = groups_on})
|
||||
|
||||
@ -233,31 +228,23 @@ register_wires()
|
||||
-- ##############
|
||||
-- ## Crafting ##
|
||||
-- ##############
|
||||
-- (Resolve aliases to avoid bug with cooking/fuel recipes.)
|
||||
minetest.register_craft({
|
||||
type = "cooking",
|
||||
output = "mesecons:wire_00000000_off 2",
|
||||
recipe = "default:mese_crystal_fragment",
|
||||
cooktime = 3,
|
||||
})
|
||||
|
||||
if minetest.registered_aliases["mesecons_gamecompat:mese_crystal_fragment"] then
|
||||
minetest.register_craft({
|
||||
type = "cooking",
|
||||
output = "mesecons:wire_00000000_off 2",
|
||||
recipe = minetest.registered_aliases["mesecons_gamecompat:mese_crystal_fragment"],
|
||||
cooktime = 3,
|
||||
})
|
||||
end
|
||||
minetest.register_craft({
|
||||
type = "cooking",
|
||||
output = "mesecons:wire_00000000_off 18",
|
||||
recipe = "default:mese_crystal",
|
||||
cooktime = 15,
|
||||
})
|
||||
|
||||
if minetest.registered_aliases["mesecons_gamecompat:mese_crystal"] then
|
||||
minetest.register_craft({
|
||||
type = "cooking",
|
||||
output = "mesecons:wire_00000000_off 18",
|
||||
recipe = minetest.registered_aliases["mesecons_gamecompat:mese_crystal"],
|
||||
cooktime = 15,
|
||||
})
|
||||
end
|
||||
|
||||
if minetest.registered_aliases["mesecons_gamecompat:mese"] then
|
||||
minetest.register_craft({
|
||||
type = "cooking",
|
||||
output = "mesecons:wire_00000000_off 162",
|
||||
recipe = minetest.registered_aliases["mesecons_gamecompat:mese"],
|
||||
cooktime = 30,
|
||||
})
|
||||
end
|
||||
minetest.register_craft({
|
||||
type = "cooking",
|
||||
output = "mesecons:wire_00000000_off 162",
|
||||
recipe = "default:mese",
|
||||
cooktime = 30,
|
||||
})
|
||||
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
|
||||
@ -1,2 +0,0 @@
|
||||
The blinky plants toggles between on and off state every three seconds. Can be used to make clocks. Also works after having restarted the game.
|
||||
It stops blinking in an inactive block, then starts again when the block becomes active.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 54 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.7 KiB |
@ -1,7 +1,5 @@
|
||||
-- The BLINKY_PLANT
|
||||
|
||||
local S = minetest.get_translator(minetest.get_current_modname())
|
||||
|
||||
local toggle_timer = function (pos)
|
||||
local timer = minetest.get_node_timer(pos)
|
||||
if timer:is_started() then
|
||||
@ -22,25 +20,18 @@ local on_timer = function (pos)
|
||||
end
|
||||
|
||||
mesecon.register_node("mesecons_blinkyplant:blinky_plant", {
|
||||
description= S("Blinky Plant"),
|
||||
description="Blinky Plant",
|
||||
drawtype = "plantlike",
|
||||
inventory_image = "jeija_blinky_plant_off.png",
|
||||
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"},
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
# textdomain: mesecons_blinkyplant
|
||||
Blinky Plant=Blinkpflanze
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons_blinkyplant
|
||||
|
||||
### init.lua ###
|
||||
Blinky Plant=Palpebruma Planto
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons_blinkyplant
|
||||
|
||||
### init.lua ###
|
||||
Blinky Plant=Plante clignotante
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons_blinkyplant
|
||||
|
||||
### init.lua ###
|
||||
Blinky Plant=Мигающий цветок
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons_blinkyplant
|
||||
|
||||
### init.lua ###
|
||||
Blinky Plant=Миготлива квітка
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons_blinkyplant
|
||||
|
||||
### init.lua ###
|
||||
Blinky Plant=
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_blinkyplant
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 367 B After Width: | Height: | Size: 454 B |
Binary file not shown.
|
Before Width: | Height: | Size: 394 B After Width: | Height: | Size: 463 B |
2
mesecons_button/depends.txt
Normal file
2
mesecons_button/depends.txt
Normal file
@ -0,0 +1,2 @@
|
||||
mesecons
|
||||
mesecons_receiver
|
||||
@ -1 +0,0 @@
|
||||
This receptor can be attached to walls. It turns on for 1 second if it's punched.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 68 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 4.3 KiB |
@ -1,38 +1,31 @@
|
||||
-- WALL BUTTON
|
||||
-- A button that when pressed emits power for 1 second
|
||||
-- and then turns off again
|
||||
local S = minetest.get_translator(minetest.get_current_modname())
|
||||
|
||||
mesecon.button_turnoff = function (pos)
|
||||
local node = minetest.get_node(pos)
|
||||
if node.name ~= "mesecons_button:button_on" then -- has been dug
|
||||
return
|
||||
if node.name=="mesecons_button:button_on" then --has not been dug
|
||||
minetest.swap_node(pos, {name = "mesecons_button:button_off", param2=node.param2})
|
||||
minetest.sound_play("mesecons_button_pop", {pos=pos})
|
||||
local rules = mesecon.rules.buttonlike_get(node)
|
||||
mesecon.receptor_off(pos, rules)
|
||||
end
|
||||
minetest.swap_node(pos, {name = "mesecons_button:button_off", param2 = node.param2})
|
||||
minetest.sound_play("mesecons_button_pop", { pos = pos }, true)
|
||||
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,
|
||||
legacy_wallmounted = true,
|
||||
walkable = false,
|
||||
on_rotate = mesecon.buttonlike_onrotate,
|
||||
sunlight_propagates = true,
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
@ -46,19 +39,18 @@ minetest.register_node("mesecons_button:button_off", {
|
||||
}
|
||||
},
|
||||
groups = {dig_immediate=2, mesecon_needs_receiver = 1},
|
||||
description = S("Button"),
|
||||
on_rightclick = function (pos, node)
|
||||
description = "Button",
|
||||
on_punch = function (pos, node)
|
||||
minetest.swap_node(pos, {name = "mesecons_button:button_on", param2=node.param2})
|
||||
mesecon.receptor_on(pos, mesecon.rules.buttonlike_get(node))
|
||||
minetest.sound_play("mesecons_button_push", { pos = pos }, true)
|
||||
minetest.get_node_timer(pos):start(1)
|
||||
minetest.sound_play("mesecons_button_push", {pos=pos})
|
||||
minetest.after(1, mesecon.button_turnoff, pos)
|
||||
end,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {receptor = {
|
||||
state = mesecon.state.off,
|
||||
rules = mesecon.rules.buttonlike_get
|
||||
}},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
}}
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_button:button_on", {
|
||||
@ -70,15 +62,12 @@ 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,
|
||||
legacy_wallmounted = true,
|
||||
walkable = false,
|
||||
on_rotate = false,
|
||||
light_source = minetest.LIGHT_MAX-7,
|
||||
light_source = LIGHT_MAX-7,
|
||||
sunlight_propagates = true,
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
@ -93,19 +82,17 @@ 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 = S("Button"),
|
||||
sounds = mesecon.node_sound.stone,
|
||||
description = "Button",
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {receptor = {
|
||||
state = mesecon.state.on,
|
||||
rules = mesecon.rules.buttonlike_get
|
||||
}},
|
||||
on_timer = mesecon.button_turnoff,
|
||||
on_blast = mesecon.on_blastnode,
|
||||
}}
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_button:button_off 2",
|
||||
recipe = {
|
||||
{"group:mesecon_conductor_craftable","mesecons_gamecompat:stone"},
|
||||
{"group:mesecon_conductor_craftable","default:stone"},
|
||||
}
|
||||
})
|
||||
|
||||
@ -1,2 +0,0 @@
|
||||
# textdomain: mesecons_button
|
||||
Button=Taster
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons_button
|
||||
|
||||
### init.lua ###
|
||||
Button=Butono
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons_button
|
||||
|
||||
### init.lua ###
|
||||
Button=Bouton
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons_button
|
||||
|
||||
### init.lua ###
|
||||
Button=Кнопка
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons_button
|
||||
|
||||
### init.lua ###
|
||||
Button=Кнопка
|
||||
@ -1,4 +0,0 @@
|
||||
# textdomain: mesecons_button
|
||||
|
||||
### init.lua ###
|
||||
Button=
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_button
|
||||
depends = mesecons, mesecons_gamecompat, mesecons_receiver
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 371 B After Width: | Height: | Size: 411 B |
Binary file not shown.
|
Before Width: | Height: | Size: 409 B After Width: | Height: | Size: 449 B |
Binary file not shown.
|
Before Width: | Height: | Size: 220 B After Width: | Height: | Size: 434 B |
1
mesecons_commandblock/depends.txt
Normal file
1
mesecons_commandblock/depends.txt
Normal file
@ -0,0 +1 @@
|
||||
mesecons
|
||||
@ -1,2 +0,0 @@
|
||||
There is no crafting recipe as this should only be available for server admins. Quite similar to the Minecraft counterpart. Executes server commands.
|
||||
It works in inactive blocks.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 33 KiB |
@ -1,9 +1,6 @@
|
||||
local S = minetest.get_translator(minetest.get_current_modname())
|
||||
local param_maxlen = mesecon.setting("commandblock_param_maxlen", 10000)
|
||||
|
||||
minetest.register_chatcommand("say", {
|
||||
params = "<text>",
|
||||
description = S("Say <text> as the server"),
|
||||
description = "Say <text> as the server",
|
||||
privs = {server=true},
|
||||
func = function(name, param)
|
||||
minetest.chat_send_all(name .. ": " .. param)
|
||||
@ -12,8 +9,7 @@ minetest.register_chatcommand("say", {
|
||||
|
||||
minetest.register_chatcommand("tell", {
|
||||
params = "<name> <text>",
|
||||
description = S("Say <text> to <name> privately"),
|
||||
privs = {shout=true},
|
||||
description = "Say <text> to <name> privately",
|
||||
func = function(name, param)
|
||||
local found, _, target, message = param:find("^([^%s]+)%s+(.*)$")
|
||||
if found == nil then
|
||||
@ -29,7 +25,7 @@ minetest.register_chatcommand("tell", {
|
||||
|
||||
minetest.register_chatcommand("hp", {
|
||||
params = "<name> <value>",
|
||||
description = S("Set health of <name> to <value> hitpoints"),
|
||||
description = "Set health of <name> to <value> hitpoints",
|
||||
privs = {ban=true},
|
||||
func = function(name, param)
|
||||
local found, _, target, value = param:find("^([^%s]+)%s+(%d+)$")
|
||||
@ -47,9 +43,9 @@ minetest.register_chatcommand("hp", {
|
||||
})
|
||||
|
||||
local function initialize_data(meta)
|
||||
local commands = minetest.formspec_escape(meta:get_string("commands"))
|
||||
local commands = meta:get_string("commands")
|
||||
meta:set_string("formspec",
|
||||
"size[9,5]" ..
|
||||
"invsize[9,5;]" ..
|
||||
"textarea[0.5,0.5;8.5,4;commands;Commands;"..commands.."]" ..
|
||||
"label[1,3.8;@nearest, @farthest, and @random are replaced by the respective player names]" ..
|
||||
"button_exit[3.3,4.5;2,1;submit;Submit]")
|
||||
@ -82,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
|
||||
@ -97,24 +93,11 @@ local function receive_fields(pos, _, fields, sender)
|
||||
end
|
||||
|
||||
local function resolve_commands(commands, pos)
|
||||
local players = minetest.get_connected_players()
|
||||
|
||||
-- No players online: remove all commands containing
|
||||
-- @nearest, @farthest and @random
|
||||
if #players == 0 then
|
||||
commands = commands:gsub("[^\r\n]+", function (line)
|
||||
if line:find("@nearest") then return "" end
|
||||
if line:find("@farthest") then return "" end
|
||||
if line:find("@random") then return "" end
|
||||
return line
|
||||
end)
|
||||
return commands
|
||||
end
|
||||
|
||||
local nearest, farthest = nil, nil
|
||||
local min_distance, max_distance = math.huge, -1
|
||||
local players = minetest.get_connected_players()
|
||||
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()
|
||||
@ -157,11 +140,6 @@ local function commandblock_action_on(pos, node)
|
||||
minetest.chat_send_player(owner, "The command "..cmd.." does not exist")
|
||||
return
|
||||
end
|
||||
if #param > param_maxlen then
|
||||
minetest.chat_send_player(owner, "Command parameters are limited to max. " ..
|
||||
param_maxlen .. " bytes.")
|
||||
return
|
||||
end
|
||||
local has_privs, missing_privs = minetest.check_player_privs(owner, cmddef.privs)
|
||||
if not has_privs then
|
||||
minetest.chat_send_player(owner, "You don't have permission "
|
||||
@ -183,30 +161,26 @@ 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", {
|
||||
description = S("Command Block"),
|
||||
description = "Command Block",
|
||||
tiles = {"jeija_commandblock_off.png"},
|
||||
inventory_image = minetest.inventorycube("jeija_commandblock_off.png"),
|
||||
is_ground_content = false,
|
||||
groups = {cracky=2, mesecon_effector_off=1},
|
||||
on_construct = construct,
|
||||
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
|
||||
}},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
}}
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_commandblock:commandblock_on", {
|
||||
tiles = {"jeija_commandblock_on.png"},
|
||||
is_ground_content = false,
|
||||
groups = {cracky=2, mesecon_effector_on=1, not_in_creative_inventory=1},
|
||||
light_source = 10,
|
||||
drop = "mesecons_commandblock:commandblock_off",
|
||||
@ -214,9 +188,8 @@ 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
|
||||
}},
|
||||
on_blast = mesecon.on_blastnode,
|
||||
}}
|
||||
})
|
||||
|
||||
@ -1,5 +0,0 @@
|
||||
# textdomain: mesecons_commandblock
|
||||
Say <text> as the server=<Text> als Server sagen
|
||||
Say <text> to <name> privately=<Text> an <Name> privat senden
|
||||
Set health of <name> to <value> hitpoints=Gesundheit von <Name> auf <Wert> Trefferpunkte setzen
|
||||
Command Block=Befehlsblock
|
||||
@ -1,7 +0,0 @@
|
||||
# textdomain: mesecons_commandblock
|
||||
|
||||
### init.lua ###
|
||||
Say <text> as the server=Diru <teksto> kiel la servilo
|
||||
Say <text> to <name> privately=Diru <teksto> al <nomo> private
|
||||
Set health of <name> to <value> hitpoints=Agordu sanon de <nomo> al <valoro>
|
||||
Command Block=Komando-Bloko
|
||||
@ -1,7 +0,0 @@
|
||||
# textdomain: mesecons_commandblock
|
||||
|
||||
### init.lua ###
|
||||
Say <text> as the server=Dire <text> au serveur
|
||||
Say <text> to <name> privately=Dire <text> à <name> en privé
|
||||
Set health of <name> to <value> hitpoints=Définir la vie de <name> sur <value> cœurs
|
||||
Command Block=Bloc de commandes
|
||||
@ -1,7 +0,0 @@
|
||||
# textdomain: mesecons_commandblock
|
||||
|
||||
### init.lua ###
|
||||
Say <text> as the server=Сказать <текст> от имени сервера
|
||||
Say <text> to <name> privately=Сказать <текст> игроку <имя> в личном сообщении
|
||||
Set health of <name> to <value> hitpoints=Установить здоровье игрока <имя> на <значение> хитпоинтов
|
||||
Command Block=Комадный блок
|
||||
@ -1,7 +0,0 @@
|
||||
# textdomain: mesecons_commandblock
|
||||
|
||||
### init.lua ###
|
||||
Say <text> as the server=Сказати <текст> від імені сервера
|
||||
Say <text> to <name> privately=Сказати <текст> гравцю <ім'я> в приватному повідомленні
|
||||
Set health of <name> to <value> hitpoints=Встановити здоров'я гравця <ім'я> на <значення> ХП
|
||||
Command Block=Командний блок
|
||||
@ -1,7 +0,0 @@
|
||||
# textdomain: mesecons_commandblock
|
||||
|
||||
### init.lua ###
|
||||
Say <text> as the server=
|
||||
Say <text> to <name> privately=
|
||||
Set health of <name> to <value> hitpoints=
|
||||
Command Block=
|
||||
@ -1,2 +0,0 @@
|
||||
name = mesecons_commandblock
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
BIN
mesecons_commandblock/textures/jeija_close_window.png
Normal file
BIN
mesecons_commandblock/textures/jeija_close_window.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 323 B |
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user