mirror of
https://github.com/minetest-mods/mesecons.git
synced 2025-06-28 22:06:03 +02:00
Compare commits
1 Commits
2016.07.09
...
patch_#135
| Author | SHA1 | Date | |
|---|---|---|---|
| 7d8fd7a8df |
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/
|
||||
@ -22,7 +22,7 @@ OK, I want in.
|
||||
--------------
|
||||
Go get it!
|
||||
|
||||
[DOWNLOAD IT NOW](https://github.com/Jeija/minetest-mod-mesecons/archive/master.zip)
|
||||
[DOWNLOADS PAGE](http://mesecons.net/downloads.php)
|
||||
|
||||
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:
|
||||
|
||||
@ -39,7 +39,7 @@ How do I use this thing?
|
||||
------------------------
|
||||
How about a [quick overview video](https://www.youtube.com/watch?v=6kmeQj6iW5k)?
|
||||
|
||||
Or maybe a [comprehensive reference](http://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](http://uberi.mesecons.net/projects/MeseconsBasics/index.html) look?
|
||||
|
||||
|
||||
@ -1,62 +0,0 @@
|
||||
{
|
||||
"Conductors" : {
|
||||
"Mesecon" : "mesecons/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",
|
||||
"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,101 +0,0 @@
|
||||
mesecon.queue.actions={} -- contains all ActionQueue actions
|
||||
|
||||
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 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 toremove = nil
|
||||
-- Otherwise, add the action to the queue
|
||||
if overwritecheck then -- check if old action has to be overwritten / removed:
|
||||
for i, ac in ipairs(mesecon.queue.actions) do
|
||||
if(vector.equals(pos, ac.pos)
|
||||
and mesecon.cmpAny(overwritecheck, ac.owcheck)) then
|
||||
toremove = i
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
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
|
||||
-- However, even that does not work in some cases, that's why we delay the time the globalsteps
|
||||
-- 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)
|
||||
minetest.register_globalstep(function (dtime)
|
||||
m_time = m_time + dtime
|
||||
-- don't even try if server has not been running for XY seconds; resumetime = time to wait
|
||||
-- after starting the server before processing the ActionQueue, don't set this too low
|
||||
if (m_time < resumetime) then return end
|
||||
local actions = mesecon.tablecopy(mesecon.queue.actions)
|
||||
local actions_now={}
|
||||
|
||||
mesecon.queue.actions = {}
|
||||
|
||||
-- sort actions into two categories:
|
||||
-- those toexecute now (actions_now) and those to execute later (mesecon.queue.actions)
|
||||
for i, ac in ipairs(actions) do
|
||||
if ac.time > 0 then
|
||||
ac.time = ac.time - dtime -- executed later
|
||||
table.insert(mesecon.queue.actions, ac)
|
||||
else
|
||||
table.insert(actions_now, ac)
|
||||
end
|
||||
end
|
||||
|
||||
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
|
||||
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
|
||||
mesecon.queue.actions = mesecon.file2table("mesecon_actionqueue")
|
||||
|
||||
minetest.register_on_shutdown(function()
|
||||
mesecon.table2file("mesecon_actionqueue", mesecon.queue.actions)
|
||||
end)
|
||||
@ -1 +0,0 @@
|
||||
Mesecons are the wires, use them to connect effectors with receptors.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 29 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 3.8 KiB |
@ -39,26 +39,53 @@
|
||||
-- }
|
||||
--}
|
||||
|
||||
|
||||
-- PUBLIC VARIABLES
|
||||
mesecon={} -- contains all functions and all global variables
|
||||
mesecon.queue={} -- contains the ActionQueue
|
||||
mesecon.queue.funcs={} -- contains all ActionQueue functions
|
||||
mesecon.actions_on={} -- Saves registered function callbacks for mesecon on | DEPRECATED
|
||||
mesecon.actions_off={} -- Saves registered function callbacks for mesecon off | DEPRECATED
|
||||
mesecon.actions_change={} -- Saves registered function callbacks for mesecon change | DEPRECATED
|
||||
mesecon.receptors={} -- saves all information about receptors | DEPRECATED
|
||||
mesecon.effectors={} -- saves all information about effectors | DEPRECATED
|
||||
mesecon.conductors={} -- saves all information about conductors | DEPRECATED
|
||||
|
||||
|
||||
local wpath = minetest.get_worldpath()
|
||||
local function read_file(fn)
|
||||
local f = io.open(fn, "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 write_file(fn, tbl)
|
||||
local f = io.open(fn, "w")
|
||||
f:write(minetest.serialize(tbl))
|
||||
f:close()
|
||||
end
|
||||
|
||||
mesecon.to_update = read_file(wpath.."/mesecon_to_update")
|
||||
mesecon.r_to_update = read_file(wpath.."/mesecon_r_to_update")
|
||||
|
||||
minetest.register_on_shutdown(function()
|
||||
write_file(wpath.."/mesecon_to_update",mesecon.to_update)
|
||||
write_file(wpath.."/mesecon_r_to_update",mesecon.r_to_update)
|
||||
end)
|
||||
|
||||
-- Settings
|
||||
dofile(minetest.get_modpath("mesecons").."/settings.lua")
|
||||
|
||||
-- Presets (eg default rules)
|
||||
dofile(minetest.get_modpath("mesecons").."/presets.lua");
|
||||
|
||||
|
||||
-- Utilities like comparing positions,
|
||||
-- adding positions and rules,
|
||||
-- mostly things that make the source look cleaner
|
||||
dofile(minetest.get_modpath("mesecons").."/util.lua");
|
||||
|
||||
-- Presets (eg default rules)
|
||||
dofile(minetest.get_modpath("mesecons").."/presets.lua");
|
||||
|
||||
-- The ActionQueue
|
||||
-- Saves all the actions that have to be execute in the future
|
||||
dofile(minetest.get_modpath("mesecons").."/actionqueue.lua");
|
||||
|
||||
-- Internal stuff
|
||||
-- This is the most important file
|
||||
-- it handles signal transmission and basically everything else
|
||||
@ -66,72 +93,62 @@ dofile(minetest.get_modpath("mesecons").."/actionqueue.lua");
|
||||
-- like calling action_on/off/change
|
||||
dofile(minetest.get_modpath("mesecons").."/internal.lua");
|
||||
|
||||
-- Deprecated stuff
|
||||
-- To be removed in future releases
|
||||
-- Currently there is nothing here
|
||||
dofile(minetest.get_modpath("mesecons").."/legacy.lua");
|
||||
|
||||
-- API
|
||||
-- these are the only functions you need to remember
|
||||
|
||||
mesecon.queue:add_function("receptor_on", function (pos, rules)
|
||||
function mesecon:receptor_on_i(pos, rules)
|
||||
rules = rules or mesecon.rules.default
|
||||
|
||||
-- if area (any of the rule targets) is not loaded, keep trying and call this again later
|
||||
for _, rule in ipairs(mesecon.flattenrules(rules)) do
|
||||
local np = vector.add(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 = vector.add(pos, rule)
|
||||
local rulenames = mesecon.rules_link_rule_all(pos, rule)
|
||||
for _, rule in ipairs(mesecon:flattenrules(rules)) do
|
||||
local np = mesecon:addPosRule(pos, rule)
|
||||
local rulenames = mesecon:rules_link_rule_all(pos, rule)
|
||||
for _, rulename in ipairs(rulenames) do
|
||||
mesecon.turnon(np, rulename)
|
||||
mesecon:turnon(np, rulename)
|
||||
end
|
||||
end
|
||||
end)
|
||||
|
||||
function mesecon.receptor_on(pos, rules)
|
||||
mesecon.queue:add_action(pos, "receptor_on", {rules}, nil, rules)
|
||||
end
|
||||
|
||||
mesecon.queue:add_function("receptor_off", function (pos, rules)
|
||||
function mesecon:receptor_on(pos, rules)
|
||||
if MESECONS_GLOBALSTEP then
|
||||
rules = rules or mesecon.rules.default
|
||||
|
||||
-- if area (any of the rule targets) is not loaded, keep trying and call this again later
|
||||
for _, rule in ipairs(mesecon.flattenrules(rules)) do
|
||||
local np = vector.add(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 = vector.add(pos, rule)
|
||||
local rulenames = mesecon.rules_link_rule_all(pos, rule)
|
||||
for _, rulename in ipairs(rulenames) do
|
||||
if not mesecon.connected_to_receptor(np, mesecon.invertRule(rule)) then
|
||||
mesecon.turnoff(np, rulename)
|
||||
mesecon.r_to_update[#mesecon.r_to_update+1]={pos=pos, rules=rules, action="on"}
|
||||
else
|
||||
mesecon.changesignal(np, minetest.get_node(np), rulename, mesecon.state.off, 2)
|
||||
mesecon:receptor_on_i(pos, rules)
|
||||
end
|
||||
end
|
||||
end
|
||||
end)
|
||||
|
||||
function mesecon.receptor_off(pos, rules)
|
||||
mesecon.queue:add_action(pos, "receptor_off", {rules}, nil, rules)
|
||||
function mesecon:receptor_off_i(pos, rules)
|
||||
rules = rules or mesecon.rules.default
|
||||
for _, rule in ipairs(mesecon:flattenrules(rules)) do
|
||||
local np = mesecon:addPosRule(pos, rule)
|
||||
local rulenames = mesecon:rules_link_rule_all(pos, rule)
|
||||
for _, rulename in ipairs(rulenames) do
|
||||
if not mesecon:connected_to_receptor(np, mesecon:invertRule(rule)) then
|
||||
mesecon:turnoff(np, rulename)
|
||||
else
|
||||
mesecon:changesignal(np, minetest.get_node(np), rulename, mesecon.state.off)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function mesecon:receptor_off(pos, rules)
|
||||
if MESECONS_GLOBALSTEP then
|
||||
rules = rules or mesecon.rules.default
|
||||
mesecon.r_to_update[#mesecon.r_to_update+1]={pos=pos, rules=rules, action="off"}
|
||||
else
|
||||
mesecon:receptor_off_i(pos, rules)
|
||||
end
|
||||
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");
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,30 +1,5 @@
|
||||
-- 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
|
||||
minetest.swap_node = minetest.swap_node or function(pos, node)
|
||||
local data = minetest.get_meta(pos):to_table()
|
||||
minetest.add_node(pos, node)
|
||||
minetest.get_meta(pos):from_table(data)
|
||||
end
|
||||
mesecon.queue:add_action(pos, "receptor_on", {rules}, nil, rules)
|
||||
end
|
||||
|
||||
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
|
||||
|
||||
|
||||
@ -30,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 = default.LIGHT_MAX-11,
|
||||
light_source = LIGHT_MAX-11,
|
||||
mesecons = {conductor={
|
||||
state = mesecon.state.on,
|
||||
offstate = "mesecons:mesecon_off"
|
||||
|
||||
@ -15,8 +15,6 @@ mesecon.rules.default =
|
||||
{x=0, y=1, z=-1},
|
||||
{x=0, y=-1, z=-1}}
|
||||
|
||||
mesecon.rules.pplate = mesecon.mergetable(mesecon.rules.default, {{x=0, y=-2, z=0}})
|
||||
|
||||
mesecon.rules.buttonlike =
|
||||
{{x = 1, y = 0, z = 0},
|
||||
{x = 1, y = 1, z = 0},
|
||||
@ -31,22 +29,14 @@ mesecon.rules.flat =
|
||||
{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}}
|
||||
|
||||
mesecon.rules.buttonlike_get = function(node)
|
||||
local rules = mesecon.rules.buttonlike
|
||||
if node.param2 == 2 then
|
||||
rules=mesecon.rotate_rules_left(rules)
|
||||
rules=mesecon:rotate_rules_left(rules)
|
||||
elseif node.param2 == 3 then
|
||||
rules=mesecon.rotate_rules_right(mesecon.rotate_rules_right(rules))
|
||||
rules=mesecon:rotate_rules_right(mesecon:rotate_rules_right(rules))
|
||||
elseif node.param2 == 0 then
|
||||
rules=mesecon.rotate_rules_right(rules)
|
||||
rules=mesecon:rotate_rules_right(rules)
|
||||
end
|
||||
return rules
|
||||
end
|
||||
|
||||
@ -1,96 +1,38 @@
|
||||
-- Dig and place services
|
||||
|
||||
mesecon.on_placenode = function (pos, node)
|
||||
mesecon.update_autoconnect(pos, node)
|
||||
|
||||
-- Receptors: Send on signal when active
|
||||
if mesecon.is_receptor_on(node.name) then
|
||||
mesecon.receptor_on(pos, mesecon.receptor_get_rules(node))
|
||||
end
|
||||
|
||||
-- Conductors: Send turnon signal when powered or replace by respective offstate conductor
|
||||
-- if placed conductor is an onstate one
|
||||
if mesecon.is_conductor(node.name) then
|
||||
local sources = mesecon.is_powered(pos)
|
||||
if sources then
|
||||
-- also call receptor_on if itself is powered already, so that neighboring
|
||||
-- conductors will be activated (when pushing an on-conductor with a piston)
|
||||
for _, s in ipairs(sources) do
|
||||
local rule = vector.subtract(pos, s)
|
||||
mesecon.turnon(pos, rule)
|
||||
end
|
||||
--mesecon.receptor_on (pos, mesecon.conductor_get_rules(node))
|
||||
elseif mesecon.is_conductor_on(node) then
|
||||
minetest.swap_node(pos, {name = mesecon.get_conductor_off(node)})
|
||||
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
|
||||
|
||||
local state = powered and mesecon.state.on or mesecon.state.off
|
||||
mesecon.changesignal(pos, node, r, state, 1)
|
||||
end
|
||||
|
||||
if (#powered_rules > 0) then
|
||||
for _, r in ipairs(powered_rules) do
|
||||
mesecon.activate(pos, node, r, 1)
|
||||
end
|
||||
if mesecon:is_receptor_on(node.name) then
|
||||
mesecon:receptor_on(pos, mesecon:receptor_get_rules(node))
|
||||
elseif mesecon:is_powered(pos) then
|
||||
if mesecon:is_conductor(node.name) then
|
||||
mesecon:turnon (pos)
|
||||
--mesecon:receptor_on (pos, mesecon:conductor_get_rules(node))
|
||||
else
|
||||
for _, r in ipairs(unpowered_rules) do
|
||||
mesecon.deactivate(pos, node, r, 1)
|
||||
end
|
||||
mesecon:changesignal(pos, node, mesecon:effector_get_rules(node), "on")
|
||||
mesecon:activate(pos, node)
|
||||
end
|
||||
elseif mesecon:is_conductor_on(node) then
|
||||
minetest.swap_node(pos, {name = mesecon:get_conductor_off(node)})
|
||||
elseif mesecon:is_effector_on (node.name) then
|
||||
mesecon:deactivate(pos, node)
|
||||
end
|
||||
end
|
||||
|
||||
mesecon.on_dignode = function (pos, node)
|
||||
if mesecon.is_conductor_on(node) then
|
||||
mesecon.receptor_off(pos, mesecon.conductor_get_rules(node))
|
||||
elseif mesecon.is_receptor_on(node.name) then
|
||||
mesecon.receptor_off(pos, mesecon.receptor_get_rules(node))
|
||||
if mesecon:is_conductor_on(node) then
|
||||
mesecon:receptor_off_i(pos, mesecon:conductor_get_rules(node))
|
||||
elseif mesecon:is_receptor_on(node.name) then
|
||||
mesecon:receptor_off(pos, mesecon:receptor_get_rules(node))
|
||||
end
|
||||
mesecon.queue:add_action(pos, "update_autoconnect", {node})
|
||||
end
|
||||
|
||||
mesecon.queue:add_function("update_autoconnect", mesecon.update_autoconnect)
|
||||
minetest.register_abm({
|
||||
nodenames = {"group:overheat"},
|
||||
interval = 1.0,
|
||||
chance = 1,
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_int("heat",0)
|
||||
end,
|
||||
})
|
||||
|
||||
minetest.register_on_placenode(mesecon.on_placenode)
|
||||
minetest.register_on_dignode(mesecon.on_dignode)
|
||||
|
||||
-- Overheating service for fast circuits
|
||||
|
||||
-- returns true if heat is too high
|
||||
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
|
||||
|
||||
|
||||
mesecon.queue:add_function("cooldown", function (pos)
|
||||
local meta = minetest.get_meta(pos)
|
||||
local heat = meta:get_int("heat")
|
||||
|
||||
if (heat > 0) then
|
||||
meta:set_int("heat", heat - 1)
|
||||
end
|
||||
end)
|
||||
|
||||
@ -1,15 +1,9 @@
|
||||
-- SETTINGS
|
||||
function mesecon.setting(setting, default)
|
||||
if type(default) == "boolean" then
|
||||
local read = minetest.setting_getbool("mesecon."..setting)
|
||||
if read == nil then
|
||||
return default
|
||||
else
|
||||
return read
|
||||
end
|
||||
elseif type(default) == "string" then
|
||||
return minetest.setting_get("mesecon."..setting) or default
|
||||
elseif type(default) == "number" then
|
||||
return tonumber(minetest.setting_get("mesecon."..setting) or default)
|
||||
end
|
||||
end
|
||||
BLINKY_PLANT_INTERVAL = 3
|
||||
NEW_STYLE_WIRES = true -- true = new nodebox wires, false = old raillike wires
|
||||
PRESSURE_PLATE_INTERVAL = 0.1
|
||||
OBJECT_DETECTOR_RADIUS = 6
|
||||
PISTON_MAXIMUM_PUSH = 15
|
||||
MOVESTONE_MAXIMUM_PUSH = 100
|
||||
MESECONS_GLOBALSTEP = true -- true = receptors/effectors won't be updated
|
||||
-- until next globalstep, decreases server load
|
||||
|
||||
@ -1,12 +1,24 @@
|
||||
function mesecon.move_node(pos, newpos)
|
||||
function mesecon:move_node(pos, newpos)
|
||||
local node = minetest.get_node(pos)
|
||||
local meta = minetest.get_meta(pos):to_table()
|
||||
minetest.remove_node(pos)
|
||||
minetest.set_node(newpos, node)
|
||||
minetest.add_node(newpos, node)
|
||||
minetest.get_meta(pos):from_table(meta)
|
||||
end
|
||||
|
||||
function mesecon.flattenrules(allrules)
|
||||
--[[ new functions:
|
||||
mesecon:flattenrules(allrules)
|
||||
mesecon:rule2bit(findrule, allrules)
|
||||
mesecon:rule2meta(findrule, allrules)
|
||||
dec2bin(n)
|
||||
mesecon:getstate(nodename, states)
|
||||
mesecon:getbinstate(nodename, states)
|
||||
mesecon:get_bit(binary, bit)
|
||||
mesecon:set_bit(binary, bit, value)
|
||||
mesecon:invertRule(r)
|
||||
--]]
|
||||
|
||||
function mesecon:flattenrules(allrules)
|
||||
--[[
|
||||
{
|
||||
{
|
||||
@ -41,7 +53,7 @@ function mesecon.flattenrules(allrules)
|
||||
--]]
|
||||
end
|
||||
|
||||
function mesecon.rule2bit(findrule, allrules)
|
||||
function mesecon:rule2bit(findrule, allrules)
|
||||
--get the bit of the metarule the rule is in, or bit 1
|
||||
if (allrules[1] and
|
||||
allrules[1].x) or
|
||||
@ -50,36 +62,35 @@ 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) and mesecon:cmpSpecial(findrule, rule) then
|
||||
return m
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function mesecon.rule2metaindex(findrule, allrules)
|
||||
function mesecon:rule2metaindex(findrule, allrules)
|
||||
--get the metarule the rule is in, or allrules
|
||||
|
||||
if allrules[1].x then
|
||||
return nil
|
||||
end
|
||||
|
||||
if not(findrule) then
|
||||
return mesecon.flattenrules(allrules)
|
||||
return mesecon:flattenrules(allrules)
|
||||
end
|
||||
|
||||
for m, metarule in ipairs( allrules) do
|
||||
for _, rule in ipairs(metarule ) do
|
||||
if vector.equals(findrule, rule) then
|
||||
if mesecon:cmpPos(findrule, rule) and mesecon:cmpSpecial(findrule, rule) then
|
||||
return m
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function mesecon.rule2meta(findrule, allrules)
|
||||
if #allrules == 0 then return {} end
|
||||
|
||||
local index = mesecon.rule2metaindex(findrule, allrules)
|
||||
function mesecon:rule2meta(findrule, allrules)
|
||||
local index = mesecon:rule2metaindex(findrule, allrules)
|
||||
if index == nil then
|
||||
if allrules[1].x then
|
||||
return allrules
|
||||
@ -90,16 +101,25 @@ function mesecon.rule2meta(findrule, allrules)
|
||||
return allrules[index]
|
||||
end
|
||||
|
||||
function mesecon.dec2bin(n)
|
||||
if convert_base then
|
||||
print(
|
||||
"base2dec is tonumber(num,base1)\n"..
|
||||
"commonlib needs dec2base(num,base2)\n"..
|
||||
"and it needs base2base(num,base1,base2),\n"..
|
||||
"which is dec2base(tonumber(num,base1),base2)"
|
||||
)
|
||||
else
|
||||
function dec2bin(n)
|
||||
local x, y = math.floor(n / 2), n % 2
|
||||
if (n > 1) then
|
||||
return mesecon.dec2bin(x)..y
|
||||
return dec2bin(x)..y
|
||||
else
|
||||
return ""..y
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function mesecon.getstate(nodename, states)
|
||||
function mesecon:getstate(nodename, states)
|
||||
for state, name in ipairs(states) do
|
||||
if name == nodename then
|
||||
return state
|
||||
@ -108,41 +128,52 @@ function mesecon.getstate(nodename, states)
|
||||
error(nodename.." doesn't mention itself in "..dump(states))
|
||||
end
|
||||
|
||||
function mesecon.getbinstate(nodename, states)
|
||||
return mesecon.dec2bin(mesecon.getstate(nodename, states)-1)
|
||||
function mesecon:getbinstate(nodename, states)
|
||||
return dec2bin(mesecon:getstate(nodename, states)-1)
|
||||
end
|
||||
|
||||
function mesecon.get_bit(binary,bit)
|
||||
function mesecon:get_bit(binary,bit)
|
||||
bit = bit or 1
|
||||
local c = binary:len()-(bit-1)
|
||||
return binary:sub(c,c) == "1"
|
||||
end
|
||||
|
||||
function mesecon.set_bit(binary,bit,value)
|
||||
function mesecon:set_bit(binary,bit,value)
|
||||
if value == "1" then
|
||||
if not mesecon.get_bit(binary,bit) then
|
||||
return mesecon.dec2bin(tonumber(binary,2)+math.pow(2,bit-1))
|
||||
if not mesecon:get_bit(binary,bit) then
|
||||
return dec2bin(tonumber(binary,2)+math.pow(2,bit-1))
|
||||
end
|
||||
elseif value == "0" then
|
||||
if mesecon.get_bit(binary,bit) then
|
||||
return mesecon.dec2bin(tonumber(binary,2)-math.pow(2,bit-1))
|
||||
if mesecon:get_bit(binary,bit) then
|
||||
return dec2bin(tonumber(binary,2)-math.pow(2,bit-1))
|
||||
end
|
||||
end
|
||||
return binary
|
||||
|
||||
end
|
||||
|
||||
function mesecon.invertRule(r)
|
||||
return vector.multiply(r, -1)
|
||||
function mesecon:invertRule(r)
|
||||
return {x = -r.x, y = -r.y, z = -r.z, sx = r.sx, sy = r.sy, sz = r.sz}
|
||||
end
|
||||
|
||||
function mesecon.tablecopy(table) -- deep table copy
|
||||
if type(table) ~= "table" then return table end -- no need to copy
|
||||
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:cmpSpecial(r1, r2)
|
||||
return (r1.sx == r2.sx and r1.sy == r2.sy and r1.sz == r2.sz)
|
||||
end
|
||||
|
||||
function mesecon:tablecopy(table) -- deep table copy
|
||||
local newtable = {}
|
||||
|
||||
for idx, item in pairs(table) do
|
||||
if type(item) == "table" then
|
||||
newtable[idx] = mesecon.tablecopy(item)
|
||||
newtable[idx] = mesecon:tablecopy(item)
|
||||
else
|
||||
newtable[idx] = item
|
||||
end
|
||||
@ -150,126 +181,3 @@ function mesecon.tablecopy(table) -- deep table copy
|
||||
|
||||
return newtable
|
||||
end
|
||||
|
||||
function mesecon.cmpAny(t1, t2)
|
||||
if type(t1) ~= type(t2) then return false end
|
||||
if type(t1) ~= "table" and type(t2) ~= "table" then return t1 == t2 end
|
||||
|
||||
for i, e in pairs(t1) do
|
||||
if not mesecon.cmpAny(e, t2[i]) then return false end
|
||||
end
|
||||
|
||||
return true
|
||||
end
|
||||
|
||||
-- does not overwrite values; number keys (ipairs) are appended, not overwritten
|
||||
function mesecon.mergetable(source, dest)
|
||||
local rval = mesecon.tablecopy(dest)
|
||||
|
||||
for k, v in pairs(source) do
|
||||
rval[k] = dest[k] or mesecon.tablecopy(v)
|
||||
end
|
||||
for i, v in ipairs(source) do
|
||||
table.insert(rval, mesecon.tablecopy(v))
|
||||
end
|
||||
|
||||
return rval
|
||||
end
|
||||
|
||||
function mesecon.register_node(name, spec_common, spec_off, spec_on)
|
||||
spec_common.drop = spec_common.drop or name .. "_off"
|
||||
spec_common.__mesecon_basename = name
|
||||
spec_on.__mesecon_state = "on"
|
||||
spec_off.__mesecon_state = "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)
|
||||
end
|
||||
|
||||
-- swap onstate and offstate nodes, returns new state
|
||||
function mesecon.flipstate(pos, node)
|
||||
local nodedef = minetest.registered_nodes[node.name]
|
||||
local newstate
|
||||
if (nodedef.__mesecon_state == "on") then newstate = "off" end
|
||||
if (nodedef.__mesecon_state == "off") then newstate = "on" end
|
||||
|
||||
minetest.swap_node(pos, {name = nodedef.__mesecon_basename .. "_" .. newstate,
|
||||
param2 = node.param2})
|
||||
|
||||
return newstate
|
||||
end
|
||||
|
||||
-- File writing / reading utilities
|
||||
local wpath = minetest.get_worldpath()
|
||||
function mesecon.file2table(filename)
|
||||
local f = io.open(wpath..DIR_DELIM..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..DIR_DELIM..filename, "w")
|
||||
f:write(minetest.serialize(table))
|
||||
f:close()
|
||||
end
|
||||
|
||||
-- Forceloading: Force server to load area if node is nil
|
||||
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
|
||||
|
||||
-- convert block hash --> node position
|
||||
local function unhash_blockpos(hash)
|
||||
return vector.multiply(minetest.get_position_from_hash(hash), BLOCKSIZE)
|
||||
end
|
||||
|
||||
mesecon.forceloaded_blocks = {}
|
||||
|
||||
-- get node and force-load area
|
||||
function mesecon.get_node_force(pos)
|
||||
local hash = hash_blockpos(pos)
|
||||
|
||||
if mesecon.forceloaded_blocks[hash] == nil then
|
||||
-- if no more forceload spaces are available, try again next time
|
||||
if minetest.forceload_block(pos) then
|
||||
mesecon.forceloaded_blocks[hash] = 0
|
||||
end
|
||||
else
|
||||
mesecon.forceloaded_blocks[hash] = 0
|
||||
end
|
||||
|
||||
return minetest.get_node_or_nil(pos)
|
||||
end
|
||||
|
||||
minetest.register_globalstep(function (dtime)
|
||||
for hash, time in pairs(mesecon.forceloaded_blocks) do
|
||||
-- unload forceloaded blocks after 10 minutes without usage
|
||||
if (time > mesecon.setting("forceload_timeout", 600)) then
|
||||
minetest.forceload_free_block(unhash_blockpos(hash))
|
||||
mesecon.forceloaded_blocks[hash] = nil
|
||||
else
|
||||
mesecon.forceloaded_blocks[hash] = time + dtime
|
||||
end
|
||||
end
|
||||
end)
|
||||
|
||||
-- Store and read the forceloaded blocks to / from a file
|
||||
-- so that those blocks are remembered when the game
|
||||
-- is restarted
|
||||
mesecon.forceloaded_blocks = mesecon.file2table("mesecon_forceloaded")
|
||||
minetest.register_on_shutdown(function()
|
||||
mesecon.table2file("mesecon_forceloaded", mesecon.forceloaded_blocks)
|
||||
end)
|
||||
|
||||
@ -1,233 +1,255 @@
|
||||
-- naming scheme: wire:(xp)(zp)(xm)(zm)(xpyp)(zpyp)(xmyp)(zmyp)_on/off
|
||||
-- where x= x direction, z= z direction, y= y direction, p = +1, m = -1, e.g. xpym = {x=1, y=-1, z=0}
|
||||
-- The (xp)/(zpyp)/.. statements shall be replaced by either 0 or 1
|
||||
-- Where 0 means the wire has no visual connection to that direction and
|
||||
-- 1 means that the wire visually connects to that other node.
|
||||
-- naming scheme: wire:(xp)(zp)(xm)(zm)_on/off
|
||||
-- The conditions in brackets define whether there is a mesecon at that place or not
|
||||
-- 1 = there is one; 0 = there is none
|
||||
-- y always means y+
|
||||
|
||||
-- #######################
|
||||
-- ## Update wire looks ##
|
||||
-- #######################
|
||||
box_center = {-1/16, -.5, -1/16, 1/16, -.5+1/16, 1/16}
|
||||
box_bump1 = { -2/16, -8/16, -2/16, 2/16, -13/32, 2/16 }
|
||||
|
||||
-- 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)
|
||||
if minetest.registered_nodes[node.name]
|
||||
and minetest.registered_nodes[node.name].mesecons then
|
||||
-- rules of node to possibly connect to
|
||||
local rules = {}
|
||||
if (minetest.registered_nodes[node.name].mesecon_wire) then
|
||||
rules = mesecon.rules.default
|
||||
else
|
||||
rules = mesecon.get_any_rules(node)
|
||||
end
|
||||
box_xp = {1/16, -.5, -1/16, 8/16, -.5+1/16, 1/16}
|
||||
box_zp = {-1/16, -.5, 1/16, 1/16, -.5+1/16, 8/16}
|
||||
box_xm = {-8/16, -.5, -1/16, -1/16, -.5+1/16, 1/16}
|
||||
box_zm = {-1/16, -.5, -8/16, 1/16, -.5+1/16, -1/16}
|
||||
|
||||
for _, r in ipairs(mesecon.flattenrules(rules)) do
|
||||
if (vector.equals(vector.add(self_pos, r), from_pos)) then
|
||||
return true
|
||||
end
|
||||
end
|
||||
end
|
||||
return false
|
||||
end
|
||||
box_xpy = {.5-1/16, -.5+1/16, -1/16, .5, .4999+1/16, 1/16}
|
||||
box_zpy = {-1/16, -.5+1/16, .5-1/16, 1/16, .4999+1/16, .5}
|
||||
box_xmy = {-.5, -.5+1/16, -1/16, -.5+1/16, .4999+1/16, 1/16}
|
||||
box_zmy = {-1/16, -.5+1/16, -.5, 1/16, .4999+1/16, -.5+1/16}
|
||||
|
||||
-- Update this node
|
||||
local wire_updateconnect = function (pos)
|
||||
local connections = {}
|
||||
-- Registering the wires
|
||||
|
||||
for _, r in ipairs(mesecon.rules.default) do
|
||||
if wire_getconnect(pos, vector.add(pos, r)) then
|
||||
table.insert(connections, r)
|
||||
end
|
||||
end
|
||||
for xp=0, 1 do
|
||||
for zp=0, 1 do
|
||||
for xm=0, 1 do
|
||||
for zm=0, 1 do
|
||||
for xpy=0, 1 do
|
||||
for zpy=0, 1 do
|
||||
for xmy=0, 1 do
|
||||
for zmy=0, 1 do
|
||||
if (xpy == 1 and xp == 0) or (zpy == 1 and zp == 0)
|
||||
or (xmy == 1 and xm == 0) or (zmy == 1 and zm == 0) then break end
|
||||
|
||||
local nid = {}
|
||||
for _, vec in ipairs(connections) do
|
||||
-- flat component
|
||||
if vec.x == 1 then nid[0] = "1" end
|
||||
if vec.z == 1 then nid[1] = "1" end
|
||||
if vec.x == -1 then nid[2] = "1" end
|
||||
if vec.z == -1 then nid[3] = "1" end
|
||||
local groups
|
||||
local nodeid = tostring(xp )..tostring(zp )..tostring(xm )..tostring(zm )..
|
||||
tostring(xpy)..tostring(zpy)..tostring(xmy)..tostring(zmy)
|
||||
|
||||
-- slopy component
|
||||
if vec.y == 1 then
|
||||
if vec.x == 1 then nid[4] = "1" end
|
||||
if vec.z == 1 then nid[5] = "1" end
|
||||
if vec.x == -1 then nid[6] = "1" end
|
||||
if vec.z == -1 then nid[7] = "1" end
|
||||
end
|
||||
end
|
||||
|
||||
local nodeid = (nid[0] or "0")..(nid[1] or "0")..(nid[2] or "0")..(nid[3] or "0")
|
||||
..(nid[4] or "0")..(nid[5] or "0")..(nid[6] or "0")..(nid[7] or "0")
|
||||
|
||||
local state_suffix = string.find(minetest.get_node(pos).name, "_off") and "_off" or "_on"
|
||||
minetest.set_node(pos, {name = "mesecons:wire_"..nodeid..state_suffix})
|
||||
end
|
||||
|
||||
local update_on_place_dig = function (pos, node)
|
||||
-- Update placed node (get_node again as it may have been dug)
|
||||
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 = {}
|
||||
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)
|
||||
end
|
||||
if (not rules) then return end
|
||||
|
||||
for _, r in ipairs(mesecon.flattenrules(rules)) do
|
||||
local np = vector.add(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
|
||||
|
||||
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 ##
|
||||
-- ############################
|
||||
-- Nodeboxes:
|
||||
local box_center = {-1/16, -.5, -1/16, 1/16, -.5+1/16, 1/16}
|
||||
local box_bump1 = { -2/16, -8/16, -2/16, 2/16, -13/32, 2/16 }
|
||||
|
||||
local nbox_nid =
|
||||
{
|
||||
[0] = {1/16, -.5, -1/16, 8/16, -.5+1/16, 1/16}, -- x positive
|
||||
[1] = {-1/16, -.5, 1/16, 1/16, -.5+1/16, 8/16}, -- z positive
|
||||
[2] = {-8/16, -.5, -1/16, -1/16, -.5+1/16, 1/16}, -- x negative
|
||||
[3] = {-1/16, -.5, -8/16, 1/16, -.5+1/16, -1/16}, -- z negative
|
||||
|
||||
[4] = {.5-1/16, -.5+1/16, -1/16, .5, .4999+1/16, 1/16}, -- x positive up
|
||||
[5] = {-1/16, -.5+1/16, .5-1/16, 1/16, .4999+1/16, .5}, -- z positive up
|
||||
[6] = {-.5, -.5+1/16, -1/16, -.5+1/16, .4999+1/16, 1/16}, -- x negative up
|
||||
[7] = {-1/16, -.5+1/16, -.5, 1/16, .4999+1/16, -.5+1/16} -- z negative up
|
||||
}
|
||||
|
||||
local tiles_off = { "mesecons_wire_off.png" }
|
||||
local tiles_on = { "mesecons_wire_on.png" }
|
||||
|
||||
local selectionbox =
|
||||
{
|
||||
type = "fixed",
|
||||
fixed = {-.5, -.5, -.5, .5, -.5+4/16, .5}
|
||||
}
|
||||
|
||||
-- go to the next nodeid (ex.: 01000011 --> 01000100)
|
||||
local nid_inc = function() end
|
||||
nid_inc = function (nid)
|
||||
local i = 0
|
||||
while nid[i-1] ~= 1 do
|
||||
nid[i] = (nid[i] ~= 1) and 1 or 0
|
||||
i = i + 1
|
||||
end
|
||||
|
||||
-- BUT: Skip impossible nodeids:
|
||||
if ((nid[0] == 0 and nid[4] == 1) or (nid[1] == 0 and nid[5] == 1)
|
||||
or (nid[2] == 0 and nid[6] == 1) or (nid[3] == 0 and nid[7] == 1)) then
|
||||
return nid_inc(nid)
|
||||
end
|
||||
|
||||
return i <= 8
|
||||
end
|
||||
|
||||
register_wires = function()
|
||||
local nid = {}
|
||||
while true do
|
||||
-- Create group specifiction and nodeid string (see note above for details)
|
||||
local nodeid = (nid[0] or "0")..(nid[1] or "0")..(nid[2] or "0")..(nid[3] or "0")
|
||||
..(nid[4] or "0")..(nid[5] or "0")..(nid[6] or "0")..(nid[7] or "0")
|
||||
|
||||
-- Calculate nodebox
|
||||
local nodebox = {type = "fixed", fixed={box_center}}
|
||||
for i=0,7 do
|
||||
if nid[i] == 1 then
|
||||
table.insert(nodebox.fixed, nbox_nid[i])
|
||||
end
|
||||
end
|
||||
|
||||
-- Add bump to nodebox if curved
|
||||
if (nid[0] == 1 and nid[1] == 1) or (nid[1] == 1 and nid[2] == 1)
|
||||
or (nid[2] == 1 and nid[3] == 1) or (nid[3] == 1 and nid[0] == 1) then
|
||||
table.insert(nodebox.fixed, box_bump1)
|
||||
end
|
||||
|
||||
-- If nothing to connect to, still make a nodebox of a straight wire
|
||||
if nodeid == "00000000" then
|
||||
nodebox.fixed = {-8/16, -.5, -1/16, 8/16, -.5+1/16, 1/16}
|
||||
groups = {dig_immediate = 3, mesecon_conductor_craftable=1}
|
||||
wiredesc = "Mesecon"
|
||||
else
|
||||
groups = {dig_immediate = 3, not_in_creative_inventory = 1}
|
||||
wiredesc = "Mesecons Wire (ID: "..nodeid..")"
|
||||
end
|
||||
|
||||
local rules = {}
|
||||
if (nid[0] == 1) then table.insert(rules, vector.new( 1, 0, 0)) end
|
||||
if (nid[1] == 1) then table.insert(rules, vector.new( 0, 0, 1)) end
|
||||
if (nid[2] == 1) then table.insert(rules, vector.new(-1, 0, 0)) end
|
||||
if (nid[3] == 1) then table.insert(rules, vector.new( 0, 0, -1)) end
|
||||
local nodebox = {}
|
||||
local adjx = false
|
||||
local adjz = false
|
||||
if xp == 1 then table.insert(nodebox, box_xp) adjx = true end
|
||||
if zp == 1 then table.insert(nodebox, box_zp) adjz = true end
|
||||
if xm == 1 then table.insert(nodebox, box_xm) adjx = true end
|
||||
if zm == 1 then table.insert(nodebox, box_zm) adjz = true end
|
||||
if xpy == 1 then table.insert(nodebox, box_xpy) end
|
||||
if zpy == 1 then table.insert(nodebox, box_zpy) end
|
||||
if xmy == 1 then table.insert(nodebox, box_xmy) end
|
||||
if zmy == 1 then table.insert(nodebox, box_zmy) end
|
||||
|
||||
if (nid[0] == 1) then table.insert(rules, vector.new( 1, -1, 0)) end
|
||||
if (nid[1] == 1) then table.insert(rules, vector.new( 0, -1, 1)) end
|
||||
if (nid[2] == 1) then table.insert(rules, vector.new(-1, -1, 0)) end
|
||||
if (nid[3] == 1) then table.insert(rules, vector.new( 0, -1, -1)) end
|
||||
|
||||
if (nid[4] == 1) then table.insert(rules, vector.new( 1, 1, 0)) end
|
||||
if (nid[5] == 1) then table.insert(rules, vector.new( 0, 1, 1)) end
|
||||
if (nid[6] == 1) then table.insert(rules, vector.new(-1, 1, 0)) end
|
||||
if (nid[7] == 1) then table.insert(rules, vector.new( 0, 1, -1)) end
|
||||
|
||||
local meseconspec_off = { conductor = {
|
||||
rules = rules,
|
||||
state = mesecon.state.off,
|
||||
onstate = "mesecons:wire_"..nodeid.."_on"
|
||||
}}
|
||||
|
||||
local meseconspec_on = { conductor = {
|
||||
rules = rules,
|
||||
state = mesecon.state.on,
|
||||
offstate = "mesecons:wire_"..nodeid.."_off"
|
||||
}}
|
||||
|
||||
local groups_on = {dig_immediate = 3, mesecon_conductor_craftable = 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
|
||||
if adjx and adjz and (xp + zp + xm + zm > 2) then
|
||||
table.insert(nodebox, box_bump1)
|
||||
tiles_off = {
|
||||
"wires_bump_off.png",
|
||||
"wires_bump_off.png",
|
||||
"wires_vertical_off.png",
|
||||
"wires_vertical_off.png",
|
||||
"wires_vertical_off.png",
|
||||
"wires_vertical_off.png"
|
||||
}
|
||||
tiles_on = {
|
||||
"wires_bump_on.png",
|
||||
"wires_bump_on.png",
|
||||
"wires_vertical_on.png",
|
||||
"wires_vertical_on.png",
|
||||
"wires_vertical_on.png",
|
||||
"wires_vertical_on.png"
|
||||
}
|
||||
else
|
||||
table.insert(nodebox, box_center)
|
||||
tiles_off = {
|
||||
"wires_off.png",
|
||||
"wires_off.png",
|
||||
"wires_vertical_off.png",
|
||||
"wires_vertical_off.png",
|
||||
"wires_vertical_off.png",
|
||||
"wires_vertical_off.png"
|
||||
}
|
||||
tiles_on = {
|
||||
"wires_on.png",
|
||||
"wires_on.png",
|
||||
"wires_vertical_on.png",
|
||||
"wires_vertical_on.png",
|
||||
"wires_vertical_on.png",
|
||||
"wires_vertical_on.png"
|
||||
}
|
||||
end
|
||||
|
||||
mesecon.register_node("mesecons:wire_"..nodeid, {
|
||||
description = "Mesecon",
|
||||
if nodeid == "00000000" then
|
||||
nodebox = {-8/16, -.5, -1/16, 8/16, -.5+1/16, 1/16}
|
||||
end
|
||||
|
||||
minetest.register_node("mesecons:wire_"..nodeid.."_off", {
|
||||
description = wiredesc,
|
||||
drawtype = "nodebox",
|
||||
inventory_image = "mesecons_wire_inv.png",
|
||||
wield_image = "mesecons_wire_inv.png",
|
||||
tiles = tiles_off,
|
||||
-- inventory_image = "wires_inv.png",
|
||||
-- wield_image = "wires_inv.png",
|
||||
inventory_image = "jeija_mesecon_off.png",
|
||||
wield_image = "jeija_mesecon_off.png",
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
sunlight_propagates = true,
|
||||
selection_box = selectionbox,
|
||||
node_box = nodebox,
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
fixed = {-.5, -.5, -.5, .5, -.5+4/16, .5}
|
||||
},
|
||||
node_box = {
|
||||
type = "fixed",
|
||||
fixed = nodebox
|
||||
},
|
||||
groups = groups,
|
||||
walkable = false,
|
||||
stack_max = 99,
|
||||
drop = "mesecons:wire_00000000_off",
|
||||
mesecon_wire = true
|
||||
}, {tiles = tiles_off, mesecons = meseconspec_off, groups = groups_off},
|
||||
{tiles = tiles_on, mesecons = meseconspec_on, groups = groups_on})
|
||||
mesecons = {conductor={
|
||||
state = mesecon.state.off,
|
||||
onstate = "mesecons:wire_"..nodeid.."_on"
|
||||
}}
|
||||
})
|
||||
|
||||
if (nid_inc(nid) == false) then return end
|
||||
minetest.register_node("mesecons:wire_"..nodeid.."_on", {
|
||||
description = "Wire ID:"..nodeid,
|
||||
drawtype = "nodebox",
|
||||
tiles = tiles_on,
|
||||
-- inventory_image = "wires_inv.png",
|
||||
-- wield_image = "wires_inv.png",
|
||||
inventory_image = "jeija_mesecon_off.png",
|
||||
wield_image = "jeija_mesecon_off.png",
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
sunlight_propagates = true,
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
fixed = {-.5, -.5, -.5, .5, -.5+4/16, .5}
|
||||
},
|
||||
node_box = {
|
||||
type = "fixed",
|
||||
fixed = nodebox
|
||||
},
|
||||
groups = {dig_immediate = 3, mesecon = 2, not_in_creative_inventory = 1},
|
||||
walkable = false,
|
||||
stack_max = 99,
|
||||
drop = "mesecons:wire_00000000_off",
|
||||
mesecons = {conductor={
|
||||
state = mesecon.state.on,
|
||||
offstate = "mesecons:wire_"..nodeid.."_off"
|
||||
}}
|
||||
})
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
register_wires()
|
||||
|
||||
-- ##############
|
||||
-- ## Crafting ##
|
||||
-- ##############
|
||||
-- Updating the wires:
|
||||
-- Place the right connection wire
|
||||
|
||||
local update_on_place_dig = function (pos, node)
|
||||
if minetest.registered_nodes[node.name]
|
||||
and minetest.registered_nodes[node.name].mesecons then
|
||||
mesecon:update_autoconnect(pos)
|
||||
end
|
||||
end
|
||||
|
||||
minetest.register_on_placenode(update_on_place_dig)
|
||||
minetest.register_on_dignode(update_on_place_dig)
|
||||
|
||||
function mesecon:update_autoconnect(pos, secondcall, replace_old)
|
||||
local xppos = {x=pos.x+1, y=pos.y, z=pos.z}
|
||||
local zppos = {x=pos.x, y=pos.y, z=pos.z+1}
|
||||
local xmpos = {x=pos.x-1, y=pos.y, z=pos.z}
|
||||
local zmpos = {x=pos.x, y=pos.y, z=pos.z-1}
|
||||
|
||||
local xpympos = {x=pos.x+1, y=pos.y-1, z=pos.z}
|
||||
local zpympos = {x=pos.x, y=pos.y-1, z=pos.z+1}
|
||||
local xmympos = {x=pos.x-1, y=pos.y-1, z=pos.z}
|
||||
local zmympos = {x=pos.x, y=pos.y-1, z=pos.z-1}
|
||||
|
||||
local xpypos = {x=pos.x+1, y=pos.y+1, z=pos.z}
|
||||
local zpypos = {x=pos.x, y=pos.y+1, z=pos.z+1}
|
||||
local xmypos = {x=pos.x-1, y=pos.y+1, z=pos.z}
|
||||
local zmypos = {x=pos.x, y=pos.y+1, z=pos.z-1}
|
||||
|
||||
if secondcall == nil then
|
||||
mesecon:update_autoconnect(xppos, true)
|
||||
mesecon:update_autoconnect(zppos, true)
|
||||
mesecon:update_autoconnect(xmpos, true)
|
||||
mesecon:update_autoconnect(zmpos, true)
|
||||
|
||||
mesecon:update_autoconnect(xpypos, true)
|
||||
mesecon:update_autoconnect(zpypos, true)
|
||||
mesecon:update_autoconnect(xmypos, true)
|
||||
mesecon:update_autoconnect(zmypos, true)
|
||||
|
||||
mesecon:update_autoconnect(xpympos, true)
|
||||
mesecon:update_autoconnect(zpympos, true)
|
||||
mesecon:update_autoconnect(xmympos, true)
|
||||
mesecon:update_autoconnect(zmympos, true)
|
||||
end
|
||||
|
||||
nodename = minetest.get_node(pos).name
|
||||
if string.find(nodename, "mesecons:wire_") == nil and not replace_old then return nil end
|
||||
|
||||
if mesecon:rules_link_anydir(pos, xppos) then xp = 1 else xp = 0 end
|
||||
if mesecon:rules_link_anydir(pos, xmpos) then xm = 1 else xm = 0 end
|
||||
if mesecon:rules_link_anydir(pos, zppos) then zp = 1 else zp = 0 end
|
||||
if mesecon:rules_link_anydir(pos, zmpos) then zm = 1 else zm = 0 end
|
||||
|
||||
if mesecon:rules_link_anydir(pos, xpympos) then xp = 1 end
|
||||
if mesecon:rules_link_anydir(pos, xmympos) then xm = 1 end
|
||||
if mesecon:rules_link_anydir(pos, zpympos) then zp = 1 end
|
||||
if mesecon:rules_link_anydir(pos, zmympos) then zm = 1 end
|
||||
|
||||
if mesecon:rules_link_anydir(pos, xpypos) then xpy = 1 else xpy = 0 end
|
||||
if mesecon:rules_link_anydir(pos, zpypos) then zpy = 1 else zpy = 0 end
|
||||
if mesecon:rules_link_anydir(pos, xmypos) then xmy = 1 else xmy = 0 end
|
||||
if mesecon:rules_link_anydir(pos, zmypos) then zmy = 1 else zmy = 0 end
|
||||
|
||||
if xpy == 1 then xp = 1 end
|
||||
if zpy == 1 then zp = 1 end
|
||||
if xmy == 1 then xm = 1 end
|
||||
if zmy == 1 then zm = 1 end
|
||||
|
||||
local nodeid = tostring(xp )..tostring(zp )..tostring(xm )..tostring(zm )..
|
||||
tostring(xpy)..tostring(zpy)..tostring(xmy)..tostring(zmy)
|
||||
|
||||
|
||||
if string.find(nodename, "_off") ~= nil then
|
||||
minetest.set_node(pos, {name = "mesecons:wire_"..nodeid.."_off"})
|
||||
else
|
||||
minetest.set_node(pos, {name = "mesecons:wire_"..nodeid.."_on" })
|
||||
end
|
||||
end
|
||||
|
||||
if not minetest.registered_nodes["default:stone_with_mese"] then --before MESE update, use old recipes
|
||||
minetest.register_craft({
|
||||
output = "mesecons:wire_00000000_off 18",
|
||||
recipe = {
|
||||
{"default:mese"},
|
||||
}
|
||||
})
|
||||
else
|
||||
|
||||
minetest.register_craft({
|
||||
type = "cooking",
|
||||
output = "mesecons:wire_00000000_off 2",
|
||||
@ -248,3 +270,11 @@ minetest.register_craft({
|
||||
recipe = "default:mese",
|
||||
cooktime = 30,
|
||||
})
|
||||
|
||||
end
|
||||
|
||||
minetest.register_craft({
|
||||
type = "cooking",
|
||||
output = "mesecons:wire_00000000_off 16",
|
||||
recipe = "default:mese_crystal",
|
||||
})
|
||||
|
||||
@ -1 +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.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 65 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 2.9 KiB |
@ -1,51 +1,102 @@
|
||||
-- The BLINKY_PLANT
|
||||
|
||||
local toggle_timer = function (pos)
|
||||
local timer = minetest.get_node_timer(pos)
|
||||
if timer:is_started() then
|
||||
timer:stop()
|
||||
else
|
||||
timer:start(mesecon.setting("blinky_plant_interval", 3))
|
||||
end
|
||||
end
|
||||
|
||||
local on_timer = function (pos)
|
||||
local node = minetest.get_node(pos)
|
||||
if(mesecon.flipstate(pos, node) == "on") then
|
||||
mesecon.receptor_on(pos)
|
||||
else
|
||||
mesecon.receptor_off(pos)
|
||||
end
|
||||
toggle_timer(pos)
|
||||
end
|
||||
|
||||
mesecon.register_node("mesecons_blinkyplant:blinky_plant", {
|
||||
description="Blinky Plant",
|
||||
minetest.register_node("mesecons_blinkyplant:blinky_plant", {
|
||||
drawtype = "plantlike",
|
||||
visual_scale = 1,
|
||||
tiles = {"jeija_blinky_plant_off.png"},
|
||||
inventory_image = "jeija_blinky_plant_off.png",
|
||||
paramtype = "light",
|
||||
walkable = false,
|
||||
groups = {dig_immediate=3, not_in_creative_inventory=1},
|
||||
drop="mesecons_blinkyplant:blinky_plant_off 1",
|
||||
description="Deactivated Blinky Plant",
|
||||
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 = toggle_timer,
|
||||
on_construct = toggle_timer
|
||||
},{
|
||||
mesecons = {receptor = {
|
||||
state = mesecon.state.off
|
||||
}},
|
||||
on_rightclick = function(pos, node, clicker)
|
||||
minetest.set_node(pos, {name="mesecons_blinkyplant:blinky_plant_off"})
|
||||
end
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_blinkyplant:blinky_plant_off", {
|
||||
drawtype = "plantlike",
|
||||
visual_scale = 1,
|
||||
tiles = {"jeija_blinky_plant_off.png"},
|
||||
groups = {dig_immediate=3},
|
||||
mesecons = {receptor = { state = mesecon.state.off }}
|
||||
},{
|
||||
inventory_image = "jeija_blinky_plant_off.png",
|
||||
paramtype = "light",
|
||||
walkable = false,
|
||||
groups = {dig_immediate=3, mesecon=2},
|
||||
description="Blinky Plant",
|
||||
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},
|
||||
},
|
||||
mesecons = {receptor = {
|
||||
state = mesecon.state.off
|
||||
}},
|
||||
on_rightclick = function(pos, node, clicker)
|
||||
minetest.set_node(pos, {name="mesecons_blinkyplant:blinky_plant"})
|
||||
end
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_blinkyplant:blinky_plant_on", {
|
||||
drawtype = "plantlike",
|
||||
visual_scale = 1,
|
||||
tiles = {"jeija_blinky_plant_on.png"},
|
||||
groups = {dig_immediate=3, not_in_creative_inventory=1},
|
||||
mesecons = {receptor = { state = mesecon.state.on }}
|
||||
inventory_image = "jeija_blinky_plant_off.png",
|
||||
paramtype = "light",
|
||||
walkable = false,
|
||||
groups = {dig_immediate=3, not_in_creative_inventory=1, mesecon=2},
|
||||
drop="mesecons_blinkyplant:blinky_plant_off 1",
|
||||
light_source = LIGHT_MAX-7,
|
||||
description = "Blinky Plant",
|
||||
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},
|
||||
},
|
||||
mesecons = {receptor = {
|
||||
state = mesecon.state.on
|
||||
}},
|
||||
on_rightclick = function(pos, node, clicker)
|
||||
minetest.set_node(pos, {name = "mesecons_blinkyplant:blinky_plant"})
|
||||
mesecon:receptor_off(pos)
|
||||
end
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_blinkyplant:blinky_plant_off 1",
|
||||
recipe = { {"","group:mesecon_conductor_craftable",""},
|
||||
recipe = {
|
||||
{"","group:mesecon_conductor_craftable",""},
|
||||
{"group:sapling","group:sapling","group:sapling"}}
|
||||
{"","group:mesecon_conductor_craftable",""},
|
||||
{"default:sapling","default:sapling","default:sapling"},
|
||||
}
|
||||
})
|
||||
|
||||
minetest.register_abm(
|
||||
{nodenames = {"mesecons_blinkyplant:blinky_plant_off"},
|
||||
interval = BLINKY_PLANT_INTERVAL,
|
||||
chance = 1,
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
--minetest.remove_node(pos)
|
||||
minetest.add_node(pos, {name="mesecons_blinkyplant:blinky_plant_on"})
|
||||
nodeupdate(pos)
|
||||
mesecon:receptor_on(pos)
|
||||
end,
|
||||
})
|
||||
|
||||
minetest.register_abm({
|
||||
nodenames = {"mesecons_blinkyplant:blinky_plant_on"},
|
||||
interval = BLINKY_PLANT_INTERVAL,
|
||||
chance = 1,
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
--minetest.remove_node(pos)
|
||||
minetest.add_node(pos, {name="mesecons_blinkyplant:blinky_plant_off"})
|
||||
nodeupdate(pos)
|
||||
mesecon:receptor_off(pos)
|
||||
end,
|
||||
})
|
||||
|
||||
@ -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: 78 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 7.8 KiB |
@ -8,7 +8,7 @@ mesecon.button_turnoff = function (pos)
|
||||
minetest.swap_node(pos, {name = "mesecons_button:button_off", param2=node.param2})
|
||||
minetest.sound_play("mesecons_button_pop", {pos=pos})
|
||||
local rules = mesecon.rules.buttonlike_get(node)
|
||||
mesecon.receptor_off(pos, rules)
|
||||
mesecon:receptor_off(pos, rules)
|
||||
end
|
||||
end
|
||||
|
||||
@ -40,9 +40,9 @@ minetest.register_node("mesecons_button:button_off", {
|
||||
},
|
||||
groups = {dig_immediate=2, mesecon_needs_receiver = 1},
|
||||
description = "Button",
|
||||
on_rightclick = function (pos, node)
|
||||
on_punch = function (pos, node)
|
||||
minetest.swap_node(pos, {name = "mesecons_button:button_on", param2=node.param2})
|
||||
mesecon.receptor_on(pos, mesecon.rules.buttonlike_get(node))
|
||||
mesecon:receptor_on(pos, mesecon.rules.buttonlike_get(node))
|
||||
minetest.sound_play("mesecons_button_push", {pos=pos})
|
||||
minetest.after(1, mesecon.button_turnoff, pos)
|
||||
end,
|
||||
@ -67,7 +67,7 @@ minetest.register_node("mesecons_button:button_on", {
|
||||
paramtype2 = "facedir",
|
||||
legacy_wallmounted = true,
|
||||
walkable = false,
|
||||
light_source = default.LIGHT_MAX-7,
|
||||
light_source = LIGHT_MAX-7,
|
||||
sunlight_propagates = true,
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
|
||||
@ -1 +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.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 36 KiB |
@ -23,6 +23,14 @@ minetest.register_chatcommand("tell", {
|
||||
end
|
||||
})
|
||||
|
||||
minetest.register_chatcommand("tellme", {
|
||||
params = "<text>",
|
||||
description = "Say <text> to yourself",
|
||||
func = function(name, param)
|
||||
minetest.chat_send_player(name, param, false)
|
||||
end
|
||||
})
|
||||
|
||||
minetest.register_chatcommand("hp", {
|
||||
params = "<name> <value>",
|
||||
description = "Set health of <name> to <value> hitpoints",
|
||||
@ -42,13 +50,16 @@ minetest.register_chatcommand("hp", {
|
||||
end
|
||||
})
|
||||
|
||||
local function initialize_data(meta)
|
||||
local commands = minetest.formspec_escape(meta:get_string("commands"))
|
||||
local initialize_data = function(meta, player, command, param)
|
||||
meta:set_string("formspec",
|
||||
"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]")
|
||||
"invsize[9,6;]" ..
|
||||
"field[1,1;7.5,1;player;Player;" .. player .. "]" ..
|
||||
"button[1.3,2;2,1;nearest;Nearest]" ..
|
||||
"button[3.3,2;2,1;farthest;Farthest]" ..
|
||||
"button[5.3,2;2,1;random;Random]" ..
|
||||
"field[1,4;2,1;command;Command;" .. command .. "]" ..
|
||||
"field[3,4;5.5,1;param;Parameter;" .. param .. "]" ..
|
||||
"button_exit[3.3,5;2,1;submit;Submit]")
|
||||
local owner = meta:get_string("owner")
|
||||
if owner == "" then
|
||||
owner = "not owned"
|
||||
@ -57,77 +68,81 @@ local function initialize_data(meta)
|
||||
end
|
||||
meta:set_string("infotext", "Command Block\n" ..
|
||||
"(" .. owner .. ")\n" ..
|
||||
"Commands: "..commands)
|
||||
"Command: /" .. command .. " " .. param)
|
||||
end
|
||||
|
||||
local function construct(pos)
|
||||
local construct = function(pos)
|
||||
local meta = minetest.get_meta(pos)
|
||||
|
||||
meta:set_string("commands", "tell @nearest Commandblock unconfigured")
|
||||
meta:set_string("player", "@nearest")
|
||||
meta:set_string("command", "time")
|
||||
meta:set_string("param", "7000")
|
||||
|
||||
meta:set_string("owner", "")
|
||||
|
||||
initialize_data(meta)
|
||||
initialize_data(meta, "@nearest", "time", "7000")
|
||||
end
|
||||
|
||||
local function after_place(pos, placer)
|
||||
local after_place = function(pos, placer)
|
||||
if placer then
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_string("owner", placer:get_player_name())
|
||||
initialize_data(meta)
|
||||
initialize_data(meta, "@nearest", "time", "7000")
|
||||
end
|
||||
end
|
||||
|
||||
local function receive_fields(pos, formname, fields, sender)
|
||||
if not fields.submit then
|
||||
local receive_fields = function(pos, formname, fields, sender)
|
||||
if fields.quit then
|
||||
return
|
||||
end
|
||||
local meta = minetest.get_meta(pos)
|
||||
local owner = meta:get_string("owner")
|
||||
if owner ~= "" and sender:get_player_name() ~= owner then
|
||||
return
|
||||
end
|
||||
meta:set_string("commands", fields.commands)
|
||||
if fields.nearest then
|
||||
initialize_data(meta, "@nearest", fields.command, fields.param)
|
||||
elseif fields.farthest then
|
||||
initialize_data(meta, "@farthest", fields.command, fields.param)
|
||||
elseif fields.random then
|
||||
initialize_data(meta, "@random", fields.command, fields.param)
|
||||
else --fields.submit or pressed enter
|
||||
meta:set_string("player", fields.player)
|
||||
meta:set_string("command", fields.command)
|
||||
meta:set_string("param", fields.param)
|
||||
|
||||
initialize_data(meta)
|
||||
initialize_data(meta, fields.player, fields.command, fields.param)
|
||||
end
|
||||
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
|
||||
local resolve_player = function(name, pos)
|
||||
local get_distance = function(pos1, pos2)
|
||||
return math.sqrt((pos1.x - pos2.x) ^ 2 + (pos1.y - pos2.y) ^ 2 + (pos1.z - pos2.z) ^ 2)
|
||||
end
|
||||
|
||||
local nearest, farthest = nil, nil
|
||||
local min_distance, max_distance = math.huge, -1
|
||||
for index, player in pairs(players) do
|
||||
local distance = vector.distance(pos, player:getpos())
|
||||
if name == "@nearest" then
|
||||
local min_distance = math.huge
|
||||
for index, player in ipairs(minetest.get_connected_players()) do
|
||||
local distance = get_distance(pos, player:getpos())
|
||||
if distance < min_distance then
|
||||
min_distance = distance
|
||||
nearest = player:get_player_name()
|
||||
name = player:get_player_name()
|
||||
end
|
||||
end
|
||||
elseif name == "@farthest" then
|
||||
local max_distance = -1
|
||||
for index, player in ipairs(minetest.get_connected_players()) do
|
||||
local distance = get_distance(pos, player:getpos())
|
||||
if distance > max_distance then
|
||||
max_distance = distance
|
||||
farthest = player:get_player_name()
|
||||
name = player:get_player_name()
|
||||
end
|
||||
end
|
||||
local random = players[math.random(#players)]:get_player_name()
|
||||
commands = commands:gsub("@nearest", nearest)
|
||||
commands = commands:gsub("@farthest", farthest)
|
||||
commands = commands:gsub("@random", random)
|
||||
return commands
|
||||
elseif name == "@random" then
|
||||
local players = minetest.get_connected_players()
|
||||
local player = players[math.random(#players)]
|
||||
name = player:get_player_name()
|
||||
end
|
||||
return name
|
||||
end
|
||||
|
||||
local function commandblock_action_on(pos, node)
|
||||
local commandblock_action_on = function(pos, node)
|
||||
if node.name ~= "mesecons_commandblock:commandblock_off" then
|
||||
return
|
||||
end
|
||||
@ -135,48 +150,29 @@ local function commandblock_action_on(pos, node)
|
||||
minetest.swap_node(pos, {name = "mesecons_commandblock:commandblock_on"})
|
||||
|
||||
local meta = minetest.get_meta(pos)
|
||||
local command = minetest.chatcommands[meta:get_string("command")]
|
||||
if command == nil then
|
||||
return
|
||||
end
|
||||
local owner = meta:get_string("owner")
|
||||
if owner == "" then
|
||||
return
|
||||
end
|
||||
|
||||
local commands = resolve_commands(meta:get_string("commands"), pos)
|
||||
for _, command in pairs(commands:split("\n")) do
|
||||
local pos = command:find(" ")
|
||||
local cmd, param = command, ""
|
||||
if pos then
|
||||
cmd = command:sub(1, pos - 1)
|
||||
param = command:sub(pos + 1)
|
||||
end
|
||||
local cmddef = minetest.chatcommands[cmd]
|
||||
if not cmddef then
|
||||
minetest.chat_send_player(owner, "The command "..cmd.." does not exist")
|
||||
return
|
||||
end
|
||||
local has_privs, missing_privs = minetest.check_player_privs(owner, cmddef.privs)
|
||||
local has_privs, missing_privs = minetest.check_player_privs(owner, command.privs)
|
||||
if not has_privs then
|
||||
minetest.chat_send_player(owner, "You don't have permission "
|
||||
.."to run "..cmd
|
||||
.." (missing privileges: "
|
||||
..table.concat(missing_privs, ", ")..")")
|
||||
minetest.chat_send_player(owner, "You don't have permission to run this command (missing privileges: "..table.concat(missing_privs, ", ")..")")
|
||||
return
|
||||
end
|
||||
cmddef.func(owner, param)
|
||||
end
|
||||
local player = resolve_player(meta:get_string("player"), pos)
|
||||
command.func(player, meta:get_string("param"))
|
||||
end
|
||||
|
||||
local function commandblock_action_off(pos, node)
|
||||
local commandblock_action_off = function(pos, node)
|
||||
if node.name == "mesecons_commandblock:commandblock_on" then
|
||||
minetest.swap_node(pos, {name = "mesecons_commandblock:commandblock_off"})
|
||||
end
|
||||
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()
|
||||
end
|
||||
|
||||
minetest.register_node("mesecons_commandblock:commandblock_off", {
|
||||
description = "Command Block",
|
||||
tiles = {"jeija_commandblock_off.png"},
|
||||
@ -185,7 +181,10 @@ minetest.register_node("mesecons_commandblock:commandblock_off", {
|
||||
on_construct = construct,
|
||||
after_place_node = after_place,
|
||||
on_receive_fields = receive_fields,
|
||||
can_dig = can_dig,
|
||||
can_dig = function(pos,player)
|
||||
local owner = minetest.get_meta(pos):get_string("owner")
|
||||
return owner == "" or owner == player:get_player_name()
|
||||
end,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {effector = {
|
||||
action_on = commandblock_action_on
|
||||
@ -200,7 +199,10 @@ minetest.register_node("mesecons_commandblock:commandblock_on", {
|
||||
on_construct = construct,
|
||||
after_place_node = after_place,
|
||||
on_receive_fields = receive_fields,
|
||||
can_dig = can_dig,
|
||||
can_dig = function(pos,player)
|
||||
local owner = minetest.get_meta(pos):get_string("owner")
|
||||
return owner == "" or owner == player:get_player_name()
|
||||
end,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {effector = {
|
||||
action_off = commandblock_action_off
|
||||
|
||||
167
mesecons_compatibility/init.lua
Normal file
167
mesecons_compatibility/init.lua
Normal file
@ -0,0 +1,167 @@
|
||||
doors = {}
|
||||
|
||||
-- Registers a door - REDEFINITION ONLY | DOORS MOD MUST HAVE BEEN LOADED BEFORE
|
||||
-- name: The name of the door
|
||||
-- def: a table with the folowing fields:
|
||||
-- description
|
||||
-- inventory_image
|
||||
-- groups
|
||||
-- tiles_bottom: the tiles of the bottom part of the door {front, side}
|
||||
-- tiles_top: the tiles of the bottom part of the door {front, side}
|
||||
-- If the following fields are not defined the default values are used
|
||||
-- node_box_bottom
|
||||
-- node_box_top
|
||||
-- selection_box_bottom
|
||||
-- selection_box_top
|
||||
-- only_placer_can_open: if true only the player who placed the door can
|
||||
-- open it
|
||||
|
||||
function doors:register_door(name, def)
|
||||
def.groups.not_in_creative_inventory = 1
|
||||
|
||||
local box = {{-0.5, -0.5, -0.5, 0.5, 0.5, -0.5+1.5/16}}
|
||||
|
||||
if not def.node_box_bottom then
|
||||
def.node_box_bottom = box
|
||||
end
|
||||
if not def.node_box_top then
|
||||
def.node_box_top = box
|
||||
end
|
||||
if not def.selection_box_bottom then
|
||||
def.selection_box_bottom= box
|
||||
end
|
||||
if not def.selection_box_top then
|
||||
def.selection_box_top = box
|
||||
end
|
||||
|
||||
local tt = def.tiles_top
|
||||
local tb = def.tiles_bottom
|
||||
|
||||
local function after_dig_node(pos, name)
|
||||
if minetest.get_node(pos).name == name then
|
||||
minetest.remove_node(pos)
|
||||
end
|
||||
end
|
||||
|
||||
local function on_rightclick(pos, dir, check_name, replace, replace_dir, params)
|
||||
pos.y = pos.y+dir
|
||||
if not minetest.get_node(pos).name == check_name then
|
||||
return
|
||||
end
|
||||
local p2 = minetest.get_node(pos).param2
|
||||
p2 = params[p2+1]
|
||||
|
||||
local meta = minetest.get_meta(pos):to_table()
|
||||
minetest.set_node(pos, {name=replace_dir, param2=p2})
|
||||
minetest.get_meta(pos):from_table(meta)
|
||||
|
||||
pos.y = pos.y-dir
|
||||
meta = minetest.get_meta(pos):to_table()
|
||||
minetest.set_node(pos, {name=replace, param2=p2})
|
||||
minetest.get_meta(pos):from_table(meta)
|
||||
end
|
||||
|
||||
local function on_mesecons_signal_open (pos, node)
|
||||
on_rightclick(pos, 1, name.."_t_1", name.."_b_2", name.."_t_2", {1,2,3,0})
|
||||
end
|
||||
|
||||
local function on_mesecons_signal_close (pos, node)
|
||||
on_rightclick(pos, 1, name.."_t_2", name.."_b_1", name.."_t_1", {3,0,1,2})
|
||||
end
|
||||
|
||||
local function check_player_priv(pos, player)
|
||||
if not def.only_placer_can_open then
|
||||
return true
|
||||
end
|
||||
local meta = minetest.get_meta(pos)
|
||||
local pn = player:get_player_name()
|
||||
return meta:get_string("doors_owner") == pn
|
||||
end
|
||||
|
||||
minetest.register_node(":"..name.."_b_1", {
|
||||
tiles = {tb[2], tb[2], tb[2], tb[2], tb[1], tb[1].."^[transformfx"},
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
drop = name,
|
||||
drawtype = "nodebox",
|
||||
node_box = {
|
||||
type = "fixed",
|
||||
fixed = def.node_box_bottom
|
||||
},
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
fixed = def.selection_box_bottom
|
||||
},
|
||||
groups = def.groups,
|
||||
|
||||
after_dig_node = function(pos, oldnode, oldmetadata, digger)
|
||||
pos.y = pos.y+1
|
||||
after_dig_node(pos, name.."_t_1")
|
||||
end,
|
||||
|
||||
on_rightclick = function(pos, node, puncher)
|
||||
if check_player_priv(pos, puncher) then
|
||||
on_rightclick(pos, 1, name.."_t_1", name.."_b_2", name.."_t_2", {1,2,3,0})
|
||||
end
|
||||
end,
|
||||
|
||||
mesecons = {effector = {
|
||||
action_on = on_mesecons_signal_open
|
||||
}},
|
||||
|
||||
can_dig = check_player_priv,
|
||||
})
|
||||
|
||||
minetest.register_node(":"..name.."_b_2", {
|
||||
tiles = {tb[2], tb[2], tb[2], tb[2], tb[1].."^[transformfx", tb[1]},
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
drop = name,
|
||||
drawtype = "nodebox",
|
||||
node_box = {
|
||||
type = "fixed",
|
||||
fixed = def.node_box_bottom
|
||||
},
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
fixed = def.selection_box_bottom
|
||||
},
|
||||
groups = def.groups,
|
||||
|
||||
after_dig_node = function(pos, oldnode, oldmetadata, digger)
|
||||
pos.y = pos.y+1
|
||||
after_dig_node(pos, name.."_t_2")
|
||||
end,
|
||||
|
||||
on_rightclick = function(pos, node, puncher)
|
||||
if check_player_priv(pos, puncher) then
|
||||
on_rightclick(pos, 1, name.."_t_2", name.."_b_1", name.."_t_1", {3,0,1,2})
|
||||
end
|
||||
end,
|
||||
|
||||
mesecons = {effector = {
|
||||
action_off = on_mesecons_signal_close
|
||||
}},
|
||||
|
||||
can_dig = check_player_priv,
|
||||
})
|
||||
end
|
||||
|
||||
doors:register_door("doors:door_wood", {
|
||||
description = "Wooden Door",
|
||||
inventory_image = "door_wood.png",
|
||||
groups = {snappy=1,choppy=2,oddly_breakable_by_hand=2,flammable=2,door=1},
|
||||
tiles_bottom = {"door_wood_b.png", "door_brown.png"},
|
||||
tiles_top = {"door_wood_a.png", "door_brown.png"},
|
||||
sounds = default.node_sound_wood_defaults(),
|
||||
})
|
||||
|
||||
doors:register_door("doors:door_steel", {
|
||||
description = "Steel Door",
|
||||
inventory_image = "door_steel.png",
|
||||
groups = {snappy=1,bendy=2,cracky=1,melty=2,level=2,door=1},
|
||||
tiles_bottom = {"door_steel_b.png", "door_grey.png"},
|
||||
tiles_top = {"door_steel_a.png", "door_grey.png"},
|
||||
only_placer_can_open = true,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
})
|
||||
@ -1 +0,0 @@
|
||||
The delayer delays the signal from the input for a determined time. The time can be set by punching the delayer. Possible delays are: 0.1 seconds, 0.3 seconds, 0.5 seconds and 1 second. You may try to use it for creating songs with the noteblock.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 61 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 8.3 KiB |
@ -2,7 +2,7 @@
|
||||
local delayer_get_output_rules = function(node)
|
||||
local rules = {{x = 0, y = 0, z = 1}}
|
||||
for i = 0, node.param2 do
|
||||
rules = mesecon.rotate_rules_left(rules)
|
||||
rules = mesecon:rotate_rules_left(rules)
|
||||
end
|
||||
return rules
|
||||
end
|
||||
@ -10,25 +10,35 @@ end
|
||||
local delayer_get_input_rules = function(node)
|
||||
local rules = {{x = 0, y = 0, z = -1}}
|
||||
for i = 0, node.param2 do
|
||||
rules = mesecon.rotate_rules_left(rules)
|
||||
rules = mesecon:rotate_rules_left(rules)
|
||||
end
|
||||
return rules
|
||||
end
|
||||
|
||||
-- Functions that are called after the delay time
|
||||
|
||||
local delayer_turnon = function(params)
|
||||
local rules = delayer_get_output_rules(params.node)
|
||||
mesecon:receptor_on(params.pos, rules)
|
||||
end
|
||||
|
||||
local delayer_turnoff = function(params)
|
||||
local rules = delayer_get_output_rules(params.node)
|
||||
mesecon:receptor_off(params.pos, rules)
|
||||
end
|
||||
|
||||
local delayer_activate = function(pos, node)
|
||||
local def = minetest.registered_nodes[node.name]
|
||||
local time = def.delayer_time
|
||||
minetest.swap_node(pos, {name = def.delayer_onstate, param2=node.param2})
|
||||
mesecon.queue:add_action(pos, "receptor_on", {delayer_get_output_rules(node)}, time, nil)
|
||||
minetest.after(time, delayer_turnon , {pos = pos, node = node})
|
||||
end
|
||||
|
||||
local delayer_deactivate = function(pos, node)
|
||||
local def = minetest.registered_nodes[node.name]
|
||||
local time = def.delayer_time
|
||||
minetest.swap_node(pos, {name = def.delayer_offstate, param2=node.param2})
|
||||
mesecon.queue:add_action(pos, "receptor_off", {delayer_get_output_rules(node)}, time, nil)
|
||||
minetest.after(time, delayer_turnoff, {pos = pos, node = node})
|
||||
end
|
||||
|
||||
-- Register the 2 (states) x 4 (delay times) delayers
|
||||
|
||||
@ -1,6 +0,0 @@
|
||||
The node detector is a receptor. It changes its state when either any node
|
||||
or a specific node is detected. Right-click it to set a nodename to scan for.
|
||||
It can also receive digiline signals. You can either send "GET" and it will
|
||||
respond with the detected nodename or you can send any other string and it will
|
||||
set this string as the node to scan for.
|
||||
Nodenames must include the mod they reside in, so for instance default:dirt, not just dirt.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 48 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 9.8 KiB |
@ -1,3 +0,0 @@
|
||||
The object detector is a receptor. It changes its state when a player approaches.
|
||||
Right-click it to set a name to scan for.
|
||||
It can also receive digiline signals which are the name to scan for on the specified channel in the right-click menu.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 84 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 9.6 KiB |
@ -1,19 +1,18 @@
|
||||
local GET_COMMAND = "GET"
|
||||
|
||||
-- Object detector
|
||||
-- Detects players in a certain radius
|
||||
-- The radius can be specified in mesecons/settings.lua
|
||||
|
||||
local function object_detector_make_formspec(pos)
|
||||
minetest.get_meta(pos):set_string("formspec", "size[9,2.5]" ..
|
||||
local object_detector_make_formspec = function (pos)
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_string("formspec", "size[9,2.5]" ..
|
||||
"field[0.3, 0;9,2;scanname;Name of player to scan for (empty for any):;${scanname}]"..
|
||||
"field[0.3,1.5;4,2;digiline_channel;Digiline Channel (optional):;${digiline_channel}]"..
|
||||
"button_exit[7,0.75;2,3;;Save]")
|
||||
"field[0.3,1.5;4,2;digiline_channel;Digiline Channel (optional):;${digiline_channel}]")
|
||||
end
|
||||
|
||||
local function object_detector_on_receive_fields(pos, _, fields)
|
||||
if not fields.scanname or not fields.digiline_channel then return end
|
||||
|
||||
local object_detector_on_receive_fields = function(pos, formname, fields)
|
||||
if fields.quit then
|
||||
return
|
||||
end
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_string("scanname", fields.scanname)
|
||||
meta:set_string("digiline_channel", fields.digiline_channel)
|
||||
@ -21,35 +20,25 @@ local function object_detector_on_receive_fields(pos, _, fields)
|
||||
end
|
||||
|
||||
-- returns true if player was found, false if not
|
||||
local function object_detector_scan(pos)
|
||||
local objs = minetest.get_objects_inside_radius(pos, mesecon.setting("detector_radius", 6))
|
||||
|
||||
-- abort if no scan results were found
|
||||
if next(objs) == nil then return false end
|
||||
|
||||
local object_detector_scan = function (pos)
|
||||
local objs = minetest.get_objects_inside_radius(pos, OBJECT_DETECTOR_RADIUS)
|
||||
for k, obj in pairs(objs) do
|
||||
local isname = obj:get_player_name() -- "" is returned if it is not a player; "" ~= nil!
|
||||
local scanname = minetest.get_meta(pos):get_string("scanname")
|
||||
local every_player = scanname == ""
|
||||
for _, obj in pairs(objs) do
|
||||
-- "" is returned if it is not a player; "" ~= nil; so only handle objects with foundname ~= ""
|
||||
local foundname = obj:get_player_name()
|
||||
|
||||
if foundname ~= "" then
|
||||
-- return true if scanning for any player or if specific playername was detected
|
||||
if scanname == "" or foundname == scanname then
|
||||
if (isname == scanname and isname ~= "") or (isname ~= "" and scanname == "") then -- player with scanname found or not scanname specified
|
||||
return true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return false
|
||||
end
|
||||
|
||||
-- set player name when receiving a digiline signal on a specific channel
|
||||
local object_detector_digiline = {
|
||||
object_detector_digiline = {
|
||||
effector = {
|
||||
action = function (pos, node, channel, msg)
|
||||
local meta = minetest.get_meta(pos)
|
||||
if channel == meta:get_string("digiline_channel") then
|
||||
local active_channel = meta:get_string("digiline_channel")
|
||||
if channel == active_channel then
|
||||
meta:set_string("scanname", msg)
|
||||
object_detector_make_formspec(pos)
|
||||
end
|
||||
@ -64,8 +53,7 @@ minetest.register_node("mesecons_detector:object_detector_off", {
|
||||
groups = {cracky=3},
|
||||
description="Player Detector",
|
||||
mesecons = {receptor = {
|
||||
state = mesecon.state.off,
|
||||
rules = mesecon.rules.pplate
|
||||
state = mesecon.state.off
|
||||
}},
|
||||
on_construct = object_detector_make_formspec,
|
||||
on_receive_fields = object_detector_on_receive_fields,
|
||||
@ -80,8 +68,7 @@ minetest.register_node("mesecons_detector:object_detector_on", {
|
||||
groups = {cracky=3,not_in_creative_inventory=1},
|
||||
drop = 'mesecons_detector:object_detector_off',
|
||||
mesecons = {receptor = {
|
||||
state = mesecon.state.on,
|
||||
rules = mesecon.rules.pplate
|
||||
state = mesecon.state.on
|
||||
}},
|
||||
on_construct = object_detector_make_formspec,
|
||||
on_receive_fields = object_detector_on_receive_fields,
|
||||
@ -98,169 +85,26 @@ minetest.register_craft({
|
||||
}
|
||||
})
|
||||
|
||||
minetest.register_abm({
|
||||
nodenames = {"mesecons_detector:object_detector_off"},
|
||||
interval = 1,
|
||||
minetest.register_abm(
|
||||
{nodenames = {"mesecons_detector:object_detector_off"},
|
||||
interval = 1.0,
|
||||
chance = 1,
|
||||
action = function(pos, node)
|
||||
if not object_detector_scan(pos) then return end
|
||||
|
||||
node.name = "mesecons_detector:object_detector_on"
|
||||
minetest.swap_node(pos, node)
|
||||
mesecon.receptor_on(pos, mesecon.rules.pplate)
|
||||
action = function(pos)
|
||||
if object_detector_scan(pos) then
|
||||
minetest.swap_node(pos, {name = "mesecons_detector:object_detector_on"})
|
||||
mesecon:receptor_on(pos)
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
minetest.register_abm({
|
||||
nodenames = {"mesecons_detector:object_detector_on"},
|
||||
interval = 1,
|
||||
minetest.register_abm(
|
||||
{nodenames = {"mesecons_detector:object_detector_on"},
|
||||
interval = 1.0,
|
||||
chance = 1,
|
||||
action = function(pos, node)
|
||||
if object_detector_scan(pos) then return end
|
||||
|
||||
node.name = "mesecons_detector:object_detector_off"
|
||||
minetest.swap_node(pos, node)
|
||||
mesecon.receptor_off(pos, mesecon.rules.pplate)
|
||||
end,
|
||||
})
|
||||
|
||||
-- Node detector
|
||||
-- Detects the node in front of it
|
||||
|
||||
local function node_detector_make_formspec(pos)
|
||||
minetest.get_meta(pos):set_string("formspec", "size[9,2.5]" ..
|
||||
"field[0.3, 0;9,2;scanname;Name of node to scan for (empty for any):;${scanname}]"..
|
||||
"field[0.3,1.5;4,2;digiline_channel;Digiline Channel (optional):;${digiline_channel}]"..
|
||||
"button_exit[7,0.75;2,3;;Save]")
|
||||
end
|
||||
|
||||
local function node_detector_on_receive_fields(pos, _, fields)
|
||||
if not fields.scanname or not fields.digiline_channel then return end
|
||||
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_string("scanname", fields.scanname)
|
||||
meta:set_string("digiline_channel", fields.digiline_channel)
|
||||
node_detector_make_formspec(pos)
|
||||
end
|
||||
|
||||
-- returns true if node was found, false if not
|
||||
local function node_detector_scan(pos)
|
||||
local node = minetest.get_node_or_nil(pos)
|
||||
if not node then return end
|
||||
|
||||
local frontname = minetest.get_node(
|
||||
vector.subtract(pos, minetest.facedir_to_dir(node.param2))
|
||||
).name
|
||||
local scanname = minetest.get_meta(pos):get_string("scanname")
|
||||
|
||||
return (frontname == scanname) or
|
||||
(frontname ~= "air" and frontname ~= "ignore" and scanname == "")
|
||||
end
|
||||
|
||||
-- set player name when receiving a digiline signal on a specific channel
|
||||
local node_detector_digiline = {
|
||||
effector = {
|
||||
action = function(pos, node, channel, msg)
|
||||
local meta = minetest.get_meta(pos)
|
||||
if channel ~= meta:get_string("digiline_channel") then return end
|
||||
|
||||
if msg == GET_COMMAND then
|
||||
local nodename = minetest.get_node(
|
||||
vector.subtract(pos, minetest.facedir_to_dir(node.param2))
|
||||
).name
|
||||
|
||||
digiline:receptor_send(pos, digiline.rules.default, channel, nodename)
|
||||
else
|
||||
meta:set_string("scanname", msg)
|
||||
node_detector_make_formspec(pos)
|
||||
action = function(pos)
|
||||
if not object_detector_scan(pos) then
|
||||
minetest.swap_node(pos, {name = "mesecons_detector:object_detector_off"})
|
||||
mesecon:receptor_off(pos)
|
||||
end
|
||||
end,
|
||||
},
|
||||
receptor = {}
|
||||
}
|
||||
|
||||
local function after_place_node_detector(pos, placer)
|
||||
local placer_pos = placer:getpos()
|
||||
if not placer_pos then
|
||||
return
|
||||
end
|
||||
|
||||
--correct for the player's height
|
||||
if placer:is_player() then
|
||||
placer_pos.y = placer_pos.y + 1.625
|
||||
end
|
||||
|
||||
--correct for 6d facedir
|
||||
local node = minetest.get_node(pos)
|
||||
node.param2 = minetest.dir_to_facedir(vector.subtract(pos, placer_pos), true)
|
||||
minetest.set_node(pos, node)
|
||||
end
|
||||
|
||||
minetest.register_node("mesecons_detector:node_detector_off", {
|
||||
tiles = {"default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "jeija_node_detector_off.png"},
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
walkable = true,
|
||||
groups = {cracky=3},
|
||||
description="Node Detector",
|
||||
mesecons = {receptor = {
|
||||
state = mesecon.state.off
|
||||
}},
|
||||
on_construct = node_detector_make_formspec,
|
||||
on_receive_fields = node_detector_on_receive_fields,
|
||||
after_place_node = after_place_node_detector,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
digiline = node_detector_digiline
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_detector:node_detector_on", {
|
||||
tiles = {"default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "default_steel_block.png", "jeija_node_detector_on.png"},
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
walkable = true,
|
||||
groups = {cracky=3,not_in_creative_inventory=1},
|
||||
drop = 'mesecons_detector:node_detector_off',
|
||||
mesecons = {receptor = {
|
||||
state = mesecon.state.on
|
||||
}},
|
||||
on_construct = node_detector_make_formspec,
|
||||
on_receive_fields = node_detector_on_receive_fields,
|
||||
after_place_node = after_place_node_detector,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
digiline = node_detector_digiline
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = 'mesecons_detector:node_detector_off',
|
||||
recipe = {
|
||||
{"default:steel_ingot", "group:mesecon_conductor_craftable", "default:steel_ingot"},
|
||||
{"default:steel_ingot", "mesecons_luacontroller:luacontroller0000", "default:steel_ingot"},
|
||||
{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
|
||||
}
|
||||
})
|
||||
|
||||
minetest.register_abm({
|
||||
nodenames = {"mesecons_detector:node_detector_off"},
|
||||
interval = 1,
|
||||
chance = 1,
|
||||
action = function(pos, node)
|
||||
if not node_detector_scan(pos) then return end
|
||||
|
||||
node.name = "mesecons_detector:node_detector_on"
|
||||
minetest.swap_node(pos, node)
|
||||
mesecon.receptor_on(pos)
|
||||
end,
|
||||
})
|
||||
|
||||
minetest.register_abm({
|
||||
nodenames = {"mesecons_detector:node_detector_on"},
|
||||
interval = 1,
|
||||
chance = 1,
|
||||
action = function(pos, node)
|
||||
if node_detector_scan(pos) then return end
|
||||
|
||||
node.name = "mesecons_detector:node_detector_off"
|
||||
minetest.swap_node(pos, node)
|
||||
mesecon.receptor_off(pos)
|
||||
end,
|
||||
})
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 717 B |
Binary file not shown.
|
Before Width: | Height: | Size: 727 B |
@ -1,129 +0,0 @@
|
||||
-- Modified, from minetest_game/mods/doors/init.lua
|
||||
local function on_rightclick(pos, dir, check_name, replace, replace_dir, params)
|
||||
pos.y = pos.y + dir
|
||||
if not minetest.get_node(pos).name == check_name then
|
||||
return
|
||||
end
|
||||
local p2 = minetest.get_node(pos).param2
|
||||
p2 = params[p2 + 1]
|
||||
|
||||
minetest.swap_node(pos, {name = replace_dir, param2 = p2})
|
||||
|
||||
pos.y = pos.y - dir
|
||||
minetest.swap_node(pos, {name = replace, param2 = p2})
|
||||
|
||||
if (minetest.get_meta(pos):get_int("right") ~= 0) == (params[1] ~= 3) then
|
||||
minetest.sound_play("doors_door_close", {pos = pos, gain = 0.3, max_hear_distance = 10})
|
||||
else
|
||||
minetest.sound_play("doors_door_open", {pos = pos, gain = 0.3, max_hear_distance = 10})
|
||||
end
|
||||
end
|
||||
|
||||
local function meseconify_door(name)
|
||||
if minetest.registered_items[name .. "_b_1"] then
|
||||
-- old style double-node doors
|
||||
local function toggle_state1 (pos, node)
|
||||
on_rightclick(pos, 1, name.."_t_1", name.."_b_2", name.."_t_2", {1,2,3,0})
|
||||
end
|
||||
|
||||
local function toggle_state2 (pos, node)
|
||||
on_rightclick(pos, 1, name.."_t_2", name.."_b_1", name.."_t_1", {3,0,1,2})
|
||||
end
|
||||
|
||||
minetest.override_item(name.."_b_1", {
|
||||
mesecons = {effector = {
|
||||
action_on = toggle_state1,
|
||||
action_off = toggle_state1,
|
||||
rules = mesecon.rules.pplate
|
||||
}}
|
||||
})
|
||||
|
||||
minetest.override_item(name.."_b_2", {
|
||||
mesecons = {effector = {
|
||||
action_on = toggle_state2,
|
||||
action_off = toggle_state2,
|
||||
rules = mesecon.rules.pplate
|
||||
}}
|
||||
})
|
||||
elseif minetest.registered_items[name .. "_a"] then
|
||||
-- new style mesh node based doors
|
||||
local override = {
|
||||
mesecons = {effector = {
|
||||
action_on = function(pos, node)
|
||||
local door = doors.get(pos)
|
||||
if door then
|
||||
door:open()
|
||||
end
|
||||
end,
|
||||
action_off = function(pos, node)
|
||||
local door = doors.get(pos)
|
||||
if door then
|
||||
door:close()
|
||||
end
|
||||
end,
|
||||
rules = mesecon.rules.pplate
|
||||
}}
|
||||
}
|
||||
minetest.override_item(name .. "_a", override)
|
||||
minetest.override_item(name .. "_b", override)
|
||||
end
|
||||
end
|
||||
|
||||
meseconify_door("doors:door_wood")
|
||||
meseconify_door("doors:door_steel")
|
||||
meseconify_door("doors:door_glass")
|
||||
meseconify_door("doors:door_obsidian_glass")
|
||||
|
||||
-- Trapdoor
|
||||
local function trapdoor_switch(pos, node)
|
||||
local state = minetest.get_meta(pos):get_int("state")
|
||||
|
||||
if state == 1 then
|
||||
minetest.sound_play("doors_door_close", {pos = pos, gain = 0.3, max_hear_distance = 10})
|
||||
minetest.set_node(pos, {name="doors:trapdoor", param2 = node.param2})
|
||||
else
|
||||
minetest.sound_play("doors_door_open", {pos = pos, gain = 0.3, max_hear_distance = 10})
|
||||
minetest.set_node(pos, {name="doors:trapdoor_open", param2 = node.param2})
|
||||
end
|
||||
|
||||
minetest.get_meta(pos):set_int("state", state == 1 and 0 or 1)
|
||||
end
|
||||
|
||||
if doors and doors.get then
|
||||
local override = {
|
||||
mesecons = {effector = {
|
||||
action_on = function(pos, node)
|
||||
local door = doors.get(pos)
|
||||
if door then
|
||||
door:open()
|
||||
end
|
||||
end,
|
||||
action_off = function(pos, node)
|
||||
local door = doors.get(pos)
|
||||
if door then
|
||||
door:close()
|
||||
end
|
||||
end,
|
||||
}},
|
||||
}
|
||||
minetest.override_item("doors:trapdoor", override)
|
||||
minetest.override_item("doors:trapdoor_open", override)
|
||||
minetest.override_item("doors:trapdoor_steel", override)
|
||||
minetest.override_item("doors:trapdoor_steel_open", override)
|
||||
else
|
||||
if minetest.registered_nodes["doors:trapdoor"] then
|
||||
minetest.override_item("doors:trapdoor", {
|
||||
mesecons = {effector = {
|
||||
action_on = trapdoor_switch,
|
||||
action_off = trapdoor_switch
|
||||
}},
|
||||
})
|
||||
|
||||
minetest.override_item("doors:trapdoor_open", {
|
||||
mesecons = {effector = {
|
||||
action_on = trapdoor_switch,
|
||||
action_off = trapdoor_switch
|
||||
}},
|
||||
})
|
||||
end
|
||||
end
|
||||
@ -15,7 +15,7 @@ local corner_get_rules = function (node)
|
||||
{x = 0, y = 0, z = -1}}
|
||||
|
||||
for i = 0, node.param2 do
|
||||
rules = mesecon.rotate_rules_left(rules)
|
||||
rules = mesecon:rotate_rules_left(rules)
|
||||
end
|
||||
|
||||
return rules
|
||||
|
||||
@ -41,7 +41,7 @@ minetest.register_node("mesecons_extrawires:crossover_off", {
|
||||
{ -3/32, -17/32, 6/32, 3/32, -13/32, 16/32+0.001 },
|
||||
},
|
||||
},
|
||||
groups = {dig_immediate=3, mesecon=3},
|
||||
groups = {dig_immediate=3, mesecon=3, mesecon_conductor_craftable=1},
|
||||
mesecons = {
|
||||
conductor = {
|
||||
states = crossover_states,
|
||||
@ -77,7 +77,7 @@ minetest.register_node("mesecons_extrawires:crossover_01", {
|
||||
{ -3/32, -17/32, 6/32, 3/32, -13/32, 16/32+0.001 },
|
||||
},
|
||||
},
|
||||
groups = {dig_immediate=3, mesecon=3, not_in_creative_inventory=1},
|
||||
groups = {dig_immediate=3, mesecon=3, mesecon_conductor_craftable=1, not_in_creative_inventory=1},
|
||||
mesecons = {
|
||||
conductor = {
|
||||
states = crossover_states,
|
||||
@ -113,7 +113,7 @@ minetest.register_node("mesecons_extrawires:crossover_10", {
|
||||
{ -3/32, -17/32, 6/32, 3/32, -13/32, 16/32+0.001 },
|
||||
},
|
||||
},
|
||||
groups = {dig_immediate=3, mesecon=3, not_in_creative_inventory=1},
|
||||
groups = {dig_immediate=3, mesecon=3, mesecon_conductor_craftable=1, not_in_creative_inventory=1},
|
||||
mesecons = {
|
||||
conductor = {
|
||||
states = crossover_states,
|
||||
@ -149,7 +149,7 @@ minetest.register_node("mesecons_extrawires:crossover_on", {
|
||||
{ -3/32, -17/32, 6/32, 3/32, -13/32, 16/32+0.001 },
|
||||
},
|
||||
},
|
||||
groups = {dig_immediate=3, mesecon=3, not_in_creative_inventory=1},
|
||||
groups = {dig_immediate=3, mesecon=3, mesecon_conductor_craftable=1, not_in_creative_inventory=1},
|
||||
mesecons = {
|
||||
conductor = {
|
||||
states = crossover_states,
|
||||
|
||||
@ -1 +0,0 @@
|
||||
Insulated corners are conductors that only conduct between the inputs (also not up or down). When placing they always point to the left in direction of your vision.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 41 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 3.8 KiB |
@ -1 +0,0 @@
|
||||
Insulated crossing are conductors that conduct two signals between the opposing sides, the signals are insulated to each other.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 61 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 3.7 KiB |
@ -1 +0,0 @@
|
||||
The basic prerequesite for mesecons, can be crafted into wires and other stuff. Have a look at the <a href="http://wiki.minetest.net/Mese">Minetest Wiki</a> for more information. Mese is a conductor. It conducts in all six directions: Up/Down/Left/Right/Forward/Backward
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 30 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 6.1 KiB |
@ -1 +0,0 @@
|
||||
Insulated T-Junctions are conductors that only conduct between the inputs (also not up or down).
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 54 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 3.9 KiB |
@ -1 +0,0 @@
|
||||
Vertical Mesecons only conduct up and down. Plates appear at the ends, at that place they also conduct to the side.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 14 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 3.0 KiB |
@ -8,7 +8,12 @@ local mesewire_rules =
|
||||
{x = 0, y = 0, z =-1},
|
||||
}
|
||||
|
||||
minetest.override_item("default:mese", {
|
||||
minetest.register_node(":default:mese", {
|
||||
description = "Mese Block",
|
||||
tiles = {minetest.registered_nodes["default:mese"].tiles[1]},
|
||||
is_ground_content = true,
|
||||
groups = {cracky=1},
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.off,
|
||||
onstate = "mesecons_extrawires:mese_powered",
|
||||
@ -16,21 +21,15 @@ minetest.override_item("default:mese", {
|
||||
}}
|
||||
})
|
||||
|
||||
-- Copy node definition of powered mese from normal mese
|
||||
-- and brighten texture tiles to indicate mese is powered
|
||||
local powered_def = mesecon.mergetable(minetest.registered_nodes["default:mese"], {
|
||||
drop = "default:mese",
|
||||
light_source = 5,
|
||||
minetest.register_node("mesecons_extrawires:mese_powered", {
|
||||
tiles = {minetest.registered_nodes["default:mese"].tiles[1].."^[brighten"},
|
||||
is_ground_content = true,
|
||||
groups = {cracky=1, not_in_creative_inventory = 1},
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.on,
|
||||
offstate = "default:mese",
|
||||
rules = mesewire_rules
|
||||
}},
|
||||
groups = {cracky = 1, not_in_creative_inventory = 1}
|
||||
drop = "default:mese"
|
||||
})
|
||||
|
||||
for i, v in pairs(powered_def.tiles) do
|
||||
powered_def.tiles[i] = v .. "^[brighten"
|
||||
end
|
||||
|
||||
minetest.register_node("mesecons_extrawires:mese_powered", powered_def)
|
||||
|
||||
@ -16,7 +16,7 @@ local tjunction_get_rules = function (node)
|
||||
{x = 0, y = 0, z = -1}}
|
||||
|
||||
for i = 0, node.param2 do
|
||||
rules = mesecon.rotate_rules_left(rules)
|
||||
rules = mesecon:rotate_rules_left(rules)
|
||||
end
|
||||
|
||||
return rules
|
||||
@ -38,7 +38,7 @@ minetest.register_node("mesecons_extrawires:tjunction_on", {
|
||||
sunlight_propagates = true,
|
||||
selection_box = tjunction_selectionbox,
|
||||
node_box = tjunction_nodebox,
|
||||
groups = {dig_immediate = 3, not_in_creative_inventory = 1},
|
||||
groups = {dig_immediate = 3, mesecon_conductor_craftable=1, not_in_creative_inventory = 1},
|
||||
drop = "mesecons_extrawires:tjunction_off",
|
||||
mesecons = {conductor =
|
||||
{
|
||||
@ -65,7 +65,7 @@ minetest.register_node("mesecons_extrawires:tjunction_off", {
|
||||
sunlight_propagates = true,
|
||||
selection_box = tjunction_selectionbox,
|
||||
node_box = tjunction_nodebox,
|
||||
groups = {dig_immediate = 3},
|
||||
groups = {dig_immediate = 3, mesecon_conductor_craftable=1},
|
||||
mesecons = {conductor =
|
||||
{
|
||||
state = mesecon.state.off,
|
||||
|
||||
@ -18,7 +18,7 @@ local bottom_box = {
|
||||
|
||||
local vertical_rules = {
|
||||
{x=0, y=1, z=0},
|
||||
{x=0, y=-1, z=0}
|
||||
{x=0, y=-1, z=0},
|
||||
}
|
||||
|
||||
local top_rules = {
|
||||
@ -26,7 +26,7 @@ local top_rules = {
|
||||
{x=-1,y=0, z=0},
|
||||
{x=0,y=0, z=1},
|
||||
{x=0,y=0, z=-1},
|
||||
{x=0,y=-1, z=0}
|
||||
{x=0,y=-1, z=0},
|
||||
}
|
||||
|
||||
local bottom_rules = {
|
||||
@ -35,81 +35,85 @@ local bottom_rules = {
|
||||
{x=0, y=0, z=1},
|
||||
{x=0, y=0, z=-1},
|
||||
{x=0, y=1, z=0},
|
||||
{x=0, y=2, z=0} -- receive power from pressure plate / detector / ... 2 nodes above
|
||||
}
|
||||
|
||||
local vertical_updatepos = function (pos)
|
||||
local node = minetest.get_node(pos)
|
||||
if minetest.registered_nodes[node.name]
|
||||
and minetest.registered_nodes[node.name].is_vertical_conductor then
|
||||
local node_above = minetest.get_node(vector.add(pos, vertical_rules[1]))
|
||||
local node_below = minetest.get_node(vector.add(pos, vertical_rules[2]))
|
||||
if minetest.registered_nodes[node.name] and minetest.registered_nodes[node.name].is_vertical_conductor then
|
||||
local node_above = minetest.get_node(mesecon:addPosRule(pos, vertical_rules[1]))
|
||||
local node_below = minetest.get_node(mesecon:addPosRule(pos, vertical_rules[2]))
|
||||
local namestate = minetest.registered_nodes[node.name].vertical_conductor_state
|
||||
|
||||
local above = minetest.registered_nodes[node_above.name]
|
||||
and minetest.registered_nodes[node_above.name].is_vertical_conductor
|
||||
local below = minetest.registered_nodes[node_below.name]
|
||||
and minetest.registered_nodes[node_below.name].is_vertical_conductor
|
||||
local above = minetest.registered_nodes[node_above.name] and minetest.registered_nodes[node_above.name].is_vertical_conductor
|
||||
local below = minetest.registered_nodes[node_below.name] and minetest.registered_nodes[node_below.name].is_vertical_conductor
|
||||
|
||||
mesecon.on_dignode(pos, node)
|
||||
|
||||
-- Always place offstate conductor and let mesecon.on_placenode take care
|
||||
local newname = "mesecons_extrawires:vertical_"
|
||||
if above and below then -- above and below: vertical mesecon
|
||||
newname = newname .. "off"
|
||||
minetest.add_node(pos, {name = "mesecons_extrawires:vertical_" .. namestate})
|
||||
elseif above and not below then -- above only: bottom
|
||||
newname = newname .. "bottom_off"
|
||||
minetest.add_node(pos, {name = "mesecons_extrawires:vertical_bottom_" .. namestate})
|
||||
elseif not above and below then -- below only: top
|
||||
newname = newname .. "top_off"
|
||||
else -- no vertical wire above, no vertical wire below: use bottom
|
||||
newname = newname .. "bottom_off"
|
||||
minetest.add_node(pos, {name = "mesecons_extrawires:vertical_top_" .. namestate})
|
||||
else -- no vertical wire above, no vertical wire below: use default wire
|
||||
minetest.add_node(pos, {name = "mesecons_extrawires:vertical_" .. namestate})
|
||||
end
|
||||
|
||||
minetest.set_node(pos, {name = newname})
|
||||
mesecon.on_placenode(pos, {name = newname})
|
||||
end
|
||||
end
|
||||
|
||||
local vertical_update = function (pos, node)
|
||||
vertical_updatepos(pos) -- this one
|
||||
vertical_updatepos(vector.add(pos, vertical_rules[1])) -- above
|
||||
vertical_updatepos(vector.add(pos, vertical_rules[2])) -- below
|
||||
vertical_updatepos(mesecon:addPosRule(pos, vertical_rules[1])) -- above
|
||||
vertical_updatepos(mesecon:addPosRule(pos, vertical_rules[2])) -- below
|
||||
end
|
||||
|
||||
-- Vertical wire
|
||||
mesecon.register_node("mesecons_extrawires:vertical", {
|
||||
minetest.register_node("mesecons_extrawires:vertical_on", {
|
||||
description = "Vertical mesecon",
|
||||
drawtype = "nodebox",
|
||||
tiles = {"wires_vertical_on.png"},
|
||||
walkable = false,
|
||||
paramtype = "light",
|
||||
sunlight_propagates = true,
|
||||
groups = {dig_immediate=3, not_in_creative_inventory=1},
|
||||
selection_box = vertical_box,
|
||||
node_box = vertical_box,
|
||||
is_vertical_conductor = true,
|
||||
drop = "mesecons_extrawires:vertical_off",
|
||||
after_place_node = vertical_update,
|
||||
after_dig_node = vertical_update
|
||||
},{
|
||||
tiles = {"mesecons_wire_off.png"},
|
||||
groups = {dig_immediate=3},
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.off,
|
||||
onstate = "mesecons_extrawires:vertical_on",
|
||||
rules = vertical_rules,
|
||||
}}
|
||||
},{
|
||||
tiles = {"mesecons_wire_on.png"},
|
||||
groups = {dig_immediate=3, not_in_creative_inventory=1},
|
||||
vertical_conductor_state = "on",
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.on,
|
||||
offstate = "mesecons_extrawires:vertical_off",
|
||||
rules = vertical_rules,
|
||||
}}
|
||||
}},
|
||||
drop = "mesecons_extrawires:vertical_off",
|
||||
after_place_node = vertical_update,
|
||||
after_dig_node = vertical_update,
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_extrawires:vertical_off", {
|
||||
description = "Vertical mesecon",
|
||||
drawtype = "nodebox",
|
||||
tiles = {"wires_vertical_off.png"},
|
||||
walkable = false,
|
||||
paramtype = "light",
|
||||
sunlight_propagates = true,
|
||||
groups = {dig_immediate=3},
|
||||
selection_box = vertical_box,
|
||||
node_box = vertical_box,
|
||||
is_vertical_conductor = true,
|
||||
vertical_conductor_state = "off",
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.off,
|
||||
onstate = "mesecons_extrawires:vertical_on",
|
||||
rules = vertical_rules,
|
||||
}},
|
||||
after_place_node = vertical_update,
|
||||
after_dig_node = vertical_update,
|
||||
})
|
||||
|
||||
-- Vertical wire top
|
||||
mesecon.register_node("mesecons_extrawires:vertical_top", {
|
||||
minetest.register_node("mesecons_extrawires:vertical_top_on", {
|
||||
description = "Vertical mesecon",
|
||||
drawtype = "nodebox",
|
||||
tiles = {"wires_full_on.png","wires_full_on.png","wires_vertical_on.png"},
|
||||
walkable = false,
|
||||
paramtype = "light",
|
||||
sunlight_propagates = true,
|
||||
@ -117,29 +121,65 @@ mesecon.register_node("mesecons_extrawires:vertical_top", {
|
||||
selection_box = top_box,
|
||||
node_box = top_box,
|
||||
is_vertical_conductor = true,
|
||||
drop = "mesecons_extrawires:vertical_off",
|
||||
after_place_node = vertical_update,
|
||||
after_dig_node = vertical_update
|
||||
},{
|
||||
tiles = {"mesecons_wire_off.png"},
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.off,
|
||||
onstate = "mesecons_extrawires:vertical_top_on",
|
||||
rules = top_rules,
|
||||
}}
|
||||
},{
|
||||
tiles = {"mesecons_wire_on.png"},
|
||||
vertical_conductor_state = "on",
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.on,
|
||||
offstate = "mesecons_extrawires:vertical_top_off",
|
||||
rules = top_rules,
|
||||
}}
|
||||
}},
|
||||
drop = "mesecons_extrawires:vertical_off",
|
||||
after_place_node = vertical_update,
|
||||
after_dig_node = vertical_update,
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_extrawires:vertical_top_off", {
|
||||
description = "Vertical mesecon",
|
||||
drawtype = "nodebox",
|
||||
tiles = {"wires_full_off.png","wires_full_off.png","wires_vertical_off.png"},
|
||||
walkable = false,
|
||||
paramtype = "light",
|
||||
sunlight_propagates = true,
|
||||
groups = {dig_immediate=3, not_in_creative_inventory=1},
|
||||
selection_box = top_box,
|
||||
node_box = top_box,
|
||||
is_vertical_conductor = true,
|
||||
vertical_conductor_state = "off",
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.off,
|
||||
onstate = "mesecons_extrawires:vertical_top_on",
|
||||
rules = top_rules,
|
||||
}},
|
||||
drop = "mesecons_extrawires:vertical_off",
|
||||
after_place_node = vertical_update,
|
||||
after_dig_node = vertical_update,
|
||||
})
|
||||
|
||||
-- Vertical wire bottom
|
||||
mesecon.register_node("mesecons_extrawires:vertical_bottom", {
|
||||
minetest.register_node("mesecons_extrawires:vertical_bottom_on", {
|
||||
description = "Vertical mesecon",
|
||||
drawtype = "nodebox",
|
||||
tiles = {"wires_full_on.png","wires_full_on.png","wires_vertical_on.png"},
|
||||
walkable = false,
|
||||
paramtype = "light",
|
||||
sunlight_propagates = true,
|
||||
vertical_conductor_state = "on",
|
||||
groups = {dig_immediate = 3, not_in_creative_inventory = 1},
|
||||
selection_box = bottom_box,
|
||||
node_box = bottom_box,
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.on,
|
||||
offstate = "mesecons_extrawires:vertical_bottom_off",
|
||||
rules = bottom_rules,
|
||||
}},
|
||||
drop = "mesecons_extrawires:vertical_off",
|
||||
after_place_node = vertical_update,
|
||||
after_dig_node = vertical_update,
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_extrawires:vertical_bottom_off", {
|
||||
description = "Vertical mesecon",
|
||||
drawtype = "nodebox",
|
||||
tiles = {"wires_full_off.png","wires_full_off.png","wires_vertical_off.png"},
|
||||
walkable = false,
|
||||
paramtype = "light",
|
||||
sunlight_propagates = true,
|
||||
@ -147,23 +187,15 @@ mesecon.register_node("mesecons_extrawires:vertical_bottom", {
|
||||
selection_box = bottom_box,
|
||||
node_box = bottom_box,
|
||||
is_vertical_conductor = true,
|
||||
drop = "mesecons_extrawires:vertical_off",
|
||||
after_place_node = vertical_update,
|
||||
after_dig_node = vertical_update
|
||||
},{
|
||||
tiles = {"mesecons_wire_off.png"},
|
||||
vertical_conductor_state = "off",
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.off,
|
||||
onstate = "mesecons_extrawires:vertical_bottom_on",
|
||||
rules = bottom_rules,
|
||||
}}
|
||||
},{
|
||||
tiles = {"mesecons_wire_on.png"},
|
||||
mesecons = {conductor = {
|
||||
state = mesecon.state.on,
|
||||
offstate = "mesecons_extrawires:vertical_bottom_off",
|
||||
rules = bottom_rules,
|
||||
}}
|
||||
}},
|
||||
drop = "mesecons_extrawires:vertical_off",
|
||||
after_place_node = vertical_update,
|
||||
after_dig_node = vertical_update,
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
|
||||
@ -1 +0,0 @@
|
||||
And gates power their output if both inputs (from left and right) are powered.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 68 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 2.7 KiB |
@ -1 +0,0 @@
|
||||
Mesecon diodes, just like real ones, only transfer power (signals) in one direction only.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 71 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 2.0 KiB |
@ -1 +0,0 @@
|
||||
Nand gates do not power their output if both inputs (from left and right) are powered, but power it in every other case.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 62 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 2.7 KiB |
@ -1 +0,0 @@
|
||||
Nor gates only power their output if none of their two inputs is powered. They are basically or gates with a not gate at their output.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 26 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 2.4 KiB |
@ -1 +0,0 @@
|
||||
Not gates invert signals, just like a mesecon torch does, but faster. The input is at the opposite side of the output.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 69 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 2.0 KiB |
@ -1 +0,0 @@
|
||||
Or gates power their output if either of their inputs (or both) are powered. You could basically get the same behaviour with two diodes, but or gates save some space.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 26 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 2.4 KiB |
@ -1 +0,0 @@
|
||||
XOR gates power their output if only one input is powered, they're off if either both or none of the inputs is powered.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 69 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 2.6 KiB |
@ -1,134 +1,223 @@
|
||||
local nodebox = {
|
||||
type = "fixed",
|
||||
fixed = {{-8/16, -8/16, -8/16, 8/16, -7/16, 8/16 }},
|
||||
}
|
||||
|
||||
local function gate_rotate_rules(node, rules)
|
||||
function gate_rotate_rules(node)
|
||||
for rotations = 0, node.param2 - 1 do
|
||||
rules = mesecon.rotate_rules_left(rules)
|
||||
rules = mesecon:rotate_rules_left(rules)
|
||||
end
|
||||
return rules
|
||||
end
|
||||
|
||||
local function gate_get_output_rules(node)
|
||||
return gate_rotate_rules(node, {{x=1, y=0, z=0}})
|
||||
function gate_get_output_rules(node)
|
||||
rules = {{x=1, y=0, z=0}}
|
||||
return gate_rotate_rules(node)
|
||||
end
|
||||
|
||||
local function gate_get_input_rules_oneinput(node)
|
||||
return gate_rotate_rules(node, {{x=-1, y=0, z=0}})
|
||||
function gate_get_input_rules_oneinput(node)
|
||||
rules = {{x=-1, y=0, z=0}, {x=1, y=0, z=0}}
|
||||
return gate_rotate_rules(node)
|
||||
end
|
||||
|
||||
local function gate_get_input_rules_twoinputs(node)
|
||||
return gate_rotate_rules(node, {{x=0, y=0, z=1, name="input1"},
|
||||
{x=0, y=0, z=-1, name="input2"}})
|
||||
function gate_get_input_rules_twoinputs(node)
|
||||
rules = {
|
||||
{x=0, y=0, z=1},
|
||||
{x=0, y=0, z=-1},
|
||||
{x=1, y=0, z=0}}
|
||||
return gate_rotate_rules(node)
|
||||
end
|
||||
|
||||
local function set_gate(pos, node, state)
|
||||
local gate = minetest.registered_nodes[node.name]
|
||||
|
||||
if mesecon.do_overheat(pos) then
|
||||
minetest.remove_node(pos)
|
||||
mesecon.receptor_off(pos, gate_get_output_rules(node))
|
||||
minetest.add_item(pos, gate.drop)
|
||||
elseif state then
|
||||
minetest.swap_node(pos, {name = gate.onstate, param2=node.param2})
|
||||
mesecon.receptor_on(pos, gate_get_output_rules(node))
|
||||
else
|
||||
minetest.swap_node(pos, {name = gate.offstate, param2=node.param2})
|
||||
mesecon.receptor_off(pos, gate_get_output_rules(node))
|
||||
function update_gate(pos)
|
||||
gate = get_gate(pos)
|
||||
L = rotate_ports(
|
||||
yc_get_real_portstates(pos),
|
||||
minetest.get_node(pos).param2
|
||||
)
|
||||
if gate == "diode" then
|
||||
set_gate(pos, L.a)
|
||||
elseif gate == "not" then
|
||||
set_gate(pos, not L.a)
|
||||
elseif gate == "nand" then
|
||||
set_gate(pos, not(L.b and L.d))
|
||||
elseif gate == "and" then
|
||||
set_gate(pos, L.b and L.d)
|
||||
elseif gate == "xor" then
|
||||
set_gate(pos, (L.b and not L.d) or (not L.b and L.d))
|
||||
end
|
||||
end
|
||||
|
||||
local function update_gate(pos, node, link, newstate)
|
||||
local gate = minetest.registered_nodes[node.name]
|
||||
|
||||
if gate.inputnumber == 1 then
|
||||
set_gate(pos, node, gate.assess(newstate == "on"))
|
||||
elseif gate.inputnumber == 2 then
|
||||
function set_gate(pos, on)
|
||||
gate = get_gate(pos)
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_int(link.name, newstate == "on" and 1 or 0)
|
||||
|
||||
local val1 = meta:get_int("input1") == 1
|
||||
local val2 = meta:get_int("input2") == 1
|
||||
set_gate(pos, node, gate.assess(val1, val2))
|
||||
if on ~= gate_state(pos) then
|
||||
yc_heat(meta)
|
||||
--minetest.after(0.5, yc_cool, meta)
|
||||
if yc_overheat(meta) then
|
||||
pop_gate(pos)
|
||||
else
|
||||
local node = minetest.get_node(pos)
|
||||
if on then
|
||||
minetest.swap_node(pos, {name = "mesecons_gates:"..gate.."_on", param2=node.param2})
|
||||
mesecon:receptor_on(pos,
|
||||
gate_get_output_rules(node))
|
||||
else
|
||||
minetest.swap_node(pos, {name = "mesecons_gates:"..gate.."_off", param2=node.param2})
|
||||
mesecon:receptor_off(pos,
|
||||
gate_get_output_rules(node))
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function register_gate(name, inputnumber, assess, recipe)
|
||||
local get_inputrules = inputnumber == 2 and gate_get_input_rules_twoinputs or
|
||||
gate_get_input_rules_oneinput
|
||||
local description = "Mesecons Logic Gate: "..name
|
||||
function get_gate(pos)
|
||||
return minetest.registered_nodes[minetest.get_node(pos).name].mesecons_gate
|
||||
end
|
||||
|
||||
local basename = "mesecons_gates:"..name
|
||||
mesecon.register_node(basename, {
|
||||
function gate_state(pos)
|
||||
name = minetest.get_node(pos).name
|
||||
return string.find(name, "_on") ~= nil
|
||||
end
|
||||
|
||||
function pop_gate(pos)
|
||||
gate = get_gate(pos)
|
||||
minetest.remove_node(pos)
|
||||
minetest.after(0.2, yc_overheat_off, pos)
|
||||
minetest.add_item(pos, "mesecons_gates:"..gate.."_off")
|
||||
end
|
||||
|
||||
function rotate_ports(L, param2)
|
||||
for rotations=0, param2-1 do
|
||||
port = L.a
|
||||
L.a = L.b
|
||||
L.b = L.c
|
||||
L.c = L.d
|
||||
L.d = port
|
||||
end
|
||||
return L
|
||||
end
|
||||
|
||||
gates = {
|
||||
{name = "diode", inputnumber = 1},
|
||||
{name = "not" , inputnumber = 1},
|
||||
{name = "nand" , inputnumber = 2},
|
||||
{name = "and" , inputnumber = 2},
|
||||
{name = "xor" , inputnumber = 2}}
|
||||
|
||||
local onoff, drop, nodename, description, groups
|
||||
for _, gate in ipairs(gates) do
|
||||
if gate.inputnumber == 1 then
|
||||
get_rules = gate_get_input_rules_oneinput
|
||||
elseif gate.inputnumber == 2 then
|
||||
get_rules = gate_get_input_rules_twoinputs
|
||||
end
|
||||
for on = 0, 1 do
|
||||
nodename = "mesecons_gates:"..gate.name
|
||||
if on == 1 then
|
||||
onoff = "on"
|
||||
drop = nodename.."_off"
|
||||
nodename = nodename.."_"..onoff
|
||||
description = "You hacker you!"
|
||||
groups = {dig_immediate=2, not_in_creative_inventory=1, overheat = 1}
|
||||
else
|
||||
onoff = "off"
|
||||
drop = nil
|
||||
nodename = nodename.."_"..onoff
|
||||
description = gate.name.." Gate"
|
||||
groups = {dig_immediate=2, overheat = 1}
|
||||
end
|
||||
|
||||
tiles = "jeija_microcontroller_bottom.png^"..
|
||||
"jeija_gate_"..onoff..".png^"..
|
||||
"jeija_gate_"..gate.name..".png"
|
||||
|
||||
node_box = {
|
||||
type = "fixed",
|
||||
fixed = {
|
||||
{-8/16, -8/16, -8/16, 8/16, -7/16, 8/16 },
|
||||
},
|
||||
}
|
||||
|
||||
local mesecon_state
|
||||
if on == 1 then
|
||||
mesecon_state = mesecon.state.on
|
||||
else
|
||||
mesecon_state = mesecon.state.off
|
||||
end
|
||||
|
||||
minetest.register_node(nodename, {
|
||||
description = description,
|
||||
inventory_image = "jeija_gate_off.png^jeija_gate_"..name..".png",
|
||||
paramtype = "light",
|
||||
paramtype2 = "facedir",
|
||||
drawtype = "nodebox",
|
||||
drop = basename.."_off",
|
||||
selection_box = nodebox,
|
||||
node_box = nodebox,
|
||||
tiles = {tiles},
|
||||
inventory_image = tiles,
|
||||
selection_box = node_box,
|
||||
node_box = node_box,
|
||||
walkable = true,
|
||||
on_construct = function(pos)
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_int("heat", 0)
|
||||
update_gate(pos)
|
||||
end,
|
||||
groups = groups,
|
||||
drop = drop,
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
assess = assess,
|
||||
onstate = basename.."_on",
|
||||
offstate = basename.."_off",
|
||||
inputnumber = inputnumber
|
||||
},{
|
||||
tiles = {"jeija_microcontroller_bottom.png^".."jeija_gate_off.png^"..
|
||||
"jeija_gate_"..name..".png"},
|
||||
groups = {dig_immediate = 2, overheat = 1},
|
||||
mesecons = { receptor = {
|
||||
state = "off",
|
||||
mesecons_gate = gate.name,
|
||||
mesecons =
|
||||
{
|
||||
receptor =
|
||||
{
|
||||
state = mesecon_state,
|
||||
rules = gate_get_output_rules
|
||||
}, effector = {
|
||||
rules = get_inputrules,
|
||||
},
|
||||
effector =
|
||||
{
|
||||
rules = get_rules,
|
||||
action_change = update_gate
|
||||
}}
|
||||
},{
|
||||
tiles = {"jeija_microcontroller_bottom.png^".."jeija_gate_on.png^"..
|
||||
"jeija_gate_"..name..".png"},
|
||||
groups = {dig_immediate = 2, not_in_creative_inventory = 1, overheat = 1},
|
||||
mesecons = { receptor = {
|
||||
state = "on",
|
||||
rules = gate_get_output_rules
|
||||
}, effector = {
|
||||
rules = get_inputrules,
|
||||
action_change = update_gate
|
||||
}}
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
minetest.register_craft({output = basename.."_off", recipe = recipe})
|
||||
end
|
||||
end
|
||||
|
||||
register_gate("diode", 1, function (input) return input end,
|
||||
{{"mesecons:mesecon", "mesecons_torch:mesecon_torch_on", "mesecons_torch:mesecon_torch_on"}})
|
||||
minetest.register_craft({
|
||||
output = 'mesecons_gates:diode_off',
|
||||
recipe = {
|
||||
{'', '', ''},
|
||||
{'mesecons:mesecon', 'mesecons_torch:mesecon_torch_on', 'mesecons_torch:mesecon_torch_on'},
|
||||
{'', '', ''},
|
||||
},
|
||||
})
|
||||
|
||||
register_gate("not", 1, function (input) return not input end,
|
||||
{{"mesecons:mesecon", "mesecons_torch:mesecon_torch_on", "mesecons:mesecon"}})
|
||||
minetest.register_craft({
|
||||
output = 'mesecons_gates:not_off',
|
||||
recipe = {
|
||||
{'', '', ''},
|
||||
{'mesecons:mesecon', 'mesecons_torch:mesecon_torch_on', 'mesecons:mesecon'},
|
||||
{'', '', ''},
|
||||
},
|
||||
})
|
||||
|
||||
register_gate("and", 2, function (val1, val2) return val1 and val2 end,
|
||||
{{"mesecons:mesecon", "", ""},
|
||||
{"", "mesecons_materials:silicon", "mesecons:mesecon"},
|
||||
{"mesecons:mesecon", "", ""}})
|
||||
minetest.register_craft({
|
||||
output = 'mesecons_gates:and_off',
|
||||
recipe = {
|
||||
{'mesecons:mesecon', '', ''},
|
||||
{'', 'mesecons_materials:silicon', 'mesecons:mesecon'},
|
||||
{'mesecons:mesecon', '', ''},
|
||||
},
|
||||
})
|
||||
|
||||
register_gate("nand", 2, function (val1, val2) return not (val1 and val2) end,
|
||||
{{"mesecons:mesecon", "", ""},
|
||||
{"", "mesecons_materials:silicon", "mesecons_torch:mesecon_torch_on"},
|
||||
{"mesecons:mesecon", "", ""}})
|
||||
minetest.register_craft({
|
||||
output = 'mesecons_gates:nand_off',
|
||||
recipe = {
|
||||
{'mesecons:mesecon', '', ''},
|
||||
{'', 'mesecons_materials:silicon', 'mesecons_torch:mesecon_torch_on'},
|
||||
{'mesecons:mesecon', '', ''},
|
||||
},
|
||||
})
|
||||
|
||||
register_gate("xor", 2, function (val1, val2) return (val1 or val2) and not (val1 and val2) end,
|
||||
{{"mesecons:mesecon", "", ""},
|
||||
{"", "mesecons_materials:silicon", "mesecons_materials:silicon"},
|
||||
{"mesecons:mesecon", "", ""}})
|
||||
minetest.register_craft({
|
||||
output = 'mesecons_gates:xor_off',
|
||||
recipe = {
|
||||
{'mesecons:mesecon', '', ''},
|
||||
{'', 'mesecons_materials:silicon', 'mesecons_materials:silicon'},
|
||||
{'mesecons:mesecon', '', ''},
|
||||
},
|
||||
})
|
||||
|
||||
register_gate("nor", 2, function (val1, val2) return not (val1 or val2) end,
|
||||
{{"mesecons:mesecon", "", ""},
|
||||
{"", "mesecons:mesecon", "mesecons_torch:mesecon_torch_on"},
|
||||
{"mesecons:mesecon", "", ""}})
|
||||
|
||||
register_gate("or", 2, function (val1, val2) return (val1 or val2) end,
|
||||
{{"mesecons:mesecon", "", ""},
|
||||
{"", "mesecons:mesecon", "mesecons:mesecon"},
|
||||
{"mesecons:mesecon", "", ""}})
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 251 B |
Binary file not shown.
|
Before Width: | Height: | Size: 243 B |
@ -1 +0,0 @@
|
||||
Water turbines are receptors that turn on if flowing water is above them.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 33 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 8.0 KiB |
@ -4,22 +4,24 @@
|
||||
-- (does not work with other liquids)
|
||||
|
||||
minetest.register_node("mesecons_hydroturbine:hydro_turbine_off", {
|
||||
drawtype = "mesh",
|
||||
mesh = "jeija_hydro_turbine.obj",
|
||||
tiles = {
|
||||
"jeija_hydro_turbine_sides_off.png",
|
||||
"jeija_hydro_turbine_top_bottom.png",
|
||||
"jeija_hydro_turbine_turbine_top_bottom.png",
|
||||
"jeija_hydro_turbine_turbine_misc.png"
|
||||
},
|
||||
inventory_image = "jeija_hydro_turbine_inv.png",
|
||||
wield_scale = {x=0.75, y=0.75, z=0.75},
|
||||
drawtype = "nodebox",
|
||||
tiles = {"jeija_hydro_turbine_off.png"},
|
||||
groups = {dig_immediate=2},
|
||||
description="Water Turbine",
|
||||
paramtype = "light",
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
fixed = { -0.5, -0.5, -0.5, 0.5, 1.5, 0.5 },
|
||||
fixed = {{-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
|
||||
{-0.15, 0.5, -0.15, 0.15, 1.45, 0.15},
|
||||
{-0.45, 1.15, -0.1, 0.45, 1.45, 0.1},
|
||||
{-0.1, 1.15, -0.45, 0.1, 1.45, 0.45}},
|
||||
},
|
||||
node_box = {
|
||||
type = "fixed",
|
||||
fixed = {{-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
|
||||
{-0.15, 0.5, -0.15, 0.15, 1.45, 0.15},
|
||||
{-0.45, 1.15, -0.1, 0.45, 1.45, 0.1},
|
||||
{-0.1, 1.15, -0.45, 0.1, 1.45, 0.45}},
|
||||
},
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {receptor = {
|
||||
@ -28,23 +30,25 @@ minetest.register_node("mesecons_hydroturbine:hydro_turbine_off", {
|
||||
})
|
||||
|
||||
minetest.register_node("mesecons_hydroturbine:hydro_turbine_on", {
|
||||
drawtype = "mesh",
|
||||
mesh = "jeija_hydro_turbine.obj",
|
||||
wield_scale = {x=0.75, y=0.75, z=0.75},
|
||||
tiles = {
|
||||
"jeija_hydro_turbine_sides_on.png",
|
||||
"jeija_hydro_turbine_top_bottom.png",
|
||||
"jeija_hydro_turbine_turbine_top_bottom.png",
|
||||
"jeija_hydro_turbine_turbine_misc.png"
|
||||
},
|
||||
inventory_image = "jeija_hydro_turbine_inv.png",
|
||||
drawtype = "nodebox",
|
||||
tiles = {"jeija_hydro_turbine_on.png"},
|
||||
drop = "mesecons_hydroturbine:hydro_turbine_off 1",
|
||||
groups = {dig_immediate=2,not_in_creative_inventory=1},
|
||||
description="Water Turbine",
|
||||
paramtype = "light",
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
fixed = { -0.5, -0.5, -0.5, 0.5, 1.5, 0.5 },
|
||||
fixed = {{-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
|
||||
{-0.15, 0.5, -0.15, 0.15, 1.45, 0.15},
|
||||
{-0.5, 1.15, -0.1, 0.5, 1.45, 0.1},
|
||||
{-0.1, 1.15, -0.5, 0.1, 1.45, 0.5}},
|
||||
},
|
||||
node_box = {
|
||||
type = "fixed",
|
||||
fixed = {{-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
|
||||
{-0.15, 0.5, -0.15, 0.15, 1.45, 0.15},
|
||||
{-0.5, 1.15, -0.1, 0.5, 1.45, 0.1},
|
||||
{-0.1, 1.15, -0.5, 0.1, 1.45, 0.5}},
|
||||
},
|
||||
sounds = default.node_sound_stone_defaults(),
|
||||
mesecons = {receptor = {
|
||||
@ -60,9 +64,9 @@ nodenames = {"mesecons_hydroturbine:hydro_turbine_off"},
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
local waterpos={x=pos.x, y=pos.y+1, z=pos.z}
|
||||
if minetest.get_node(waterpos).name=="default:water_flowing" then
|
||||
minetest.set_node(pos, {name="mesecons_hydroturbine:hydro_turbine_on"})
|
||||
minetest.add_node(pos, {name="mesecons_hydroturbine:hydro_turbine_on"})
|
||||
nodeupdate(pos)
|
||||
mesecon.receptor_on(pos)
|
||||
mesecon:receptor_on(pos)
|
||||
end
|
||||
end,
|
||||
})
|
||||
@ -74,9 +78,9 @@ nodenames = {"mesecons_hydroturbine:hydro_turbine_on"},
|
||||
action = function(pos, node, active_object_count, active_object_count_wider)
|
||||
local waterpos={x=pos.x, y=pos.y+1, z=pos.z}
|
||||
if minetest.get_node(waterpos).name~="default:water_flowing" then
|
||||
minetest.set_node(pos, {name="mesecons_hydroturbine:hydro_turbine_off"})
|
||||
minetest.add_node(pos, {name="mesecons_hydroturbine:hydro_turbine_off"})
|
||||
nodeupdate(pos)
|
||||
mesecon.receptor_off(pos)
|
||||
mesecon:receptor_off(pos)
|
||||
end
|
||||
end,
|
||||
})
|
||||
|
||||
@ -1,429 +0,0 @@
|
||||
# Blender v2.73 (sub 0) OBJ File: 'mesecons-water-turbine.blend'
|
||||
# www.blender.org
|
||||
o Cylinder.002_Cylinder.003
|
||||
v 0.000000 0.500000 -0.150000
|
||||
v 0.000000 0.562500 -0.150000
|
||||
v 0.106066 0.500000 -0.106066
|
||||
v 0.106066 0.562500 -0.106066
|
||||
v 0.150000 0.500000 0.000000
|
||||
v 0.150000 0.562500 0.000000
|
||||
v 0.106066 0.500000 0.106066
|
||||
v 0.106066 0.562500 0.106066
|
||||
v -0.000000 0.500000 0.150000
|
||||
v -0.000000 0.562500 0.150000
|
||||
v -0.106066 0.500000 0.106066
|
||||
v -0.106066 0.562500 0.106066
|
||||
v -0.150000 0.500000 -0.000000
|
||||
v -0.150000 0.562500 -0.000000
|
||||
v -0.106066 0.500000 -0.106066
|
||||
v -0.106066 0.562500 -0.106066
|
||||
v 0.097545 0.625000 -0.490393
|
||||
v -0.097545 0.625000 -0.490393
|
||||
v -0.277785 0.625000 -0.415735
|
||||
v -0.415735 0.625000 -0.277785
|
||||
v -0.490393 0.625000 -0.097545
|
||||
v -0.490393 0.625000 0.097545
|
||||
v -0.415735 0.625000 0.277785
|
||||
v -0.277785 0.625000 0.415735
|
||||
v -0.097545 0.625000 0.490393
|
||||
v 0.097545 0.625000 0.490393
|
||||
v 0.277785 0.625000 0.415735
|
||||
v 0.415735 0.625000 0.277785
|
||||
v 0.490393 0.625000 0.097545
|
||||
v 0.490393 0.625000 -0.097545
|
||||
v 0.415735 0.625000 -0.277785
|
||||
v 0.277785 0.625000 -0.415735
|
||||
v 0.097545 0.656250 -0.490393
|
||||
v -0.097545 0.656250 -0.490393
|
||||
v -0.277785 0.656250 -0.415735
|
||||
v -0.415735 0.656250 -0.277785
|
||||
v -0.490393 0.656250 -0.097545
|
||||
v -0.490393 0.656250 0.097545
|
||||
v -0.415735 0.656250 0.277785
|
||||
v -0.277785 0.656250 0.415735
|
||||
v -0.097545 0.656250 0.490393
|
||||
v 0.097545 0.656250 0.490393
|
||||
v 0.277785 0.656250 0.415735
|
||||
v 0.415735 0.656250 0.277785
|
||||
v 0.490393 0.656250 0.097545
|
||||
v 0.490393 0.656250 -0.097545
|
||||
v 0.415735 0.656250 -0.277785
|
||||
v 0.277785 0.656250 -0.415735
|
||||
v 0.116233 0.634645 -0.436100
|
||||
v 0.116233 1.482640 -0.436100
|
||||
v 0.299524 0.634645 -0.186124
|
||||
v 0.299524 1.482640 -0.186124
|
||||
v 0.343405 0.634645 0.080186
|
||||
v 0.343405 1.482640 0.080186
|
||||
v 0.186124 0.634645 0.299524
|
||||
v 0.186124 1.482640 0.299524
|
||||
v -0.080186 0.634645 0.343405
|
||||
v -0.080186 1.482640 0.343405
|
||||
v -0.299524 0.634645 0.186124
|
||||
v -0.299524 1.482640 0.186124
|
||||
v -0.343405 0.634645 -0.080186
|
||||
v -0.343405 1.482640 -0.080186
|
||||
v -0.186124 0.634645 -0.299524
|
||||
v -0.186124 1.482640 -0.299524
|
||||
v 0.080186 0.634645 -0.343405
|
||||
v 0.080186 1.482640 -0.343405
|
||||
v 0.390559 1.482640 -0.226180
|
||||
v 0.390559 0.634645 -0.226180
|
||||
v 0.436100 1.482640 0.116233
|
||||
v 0.436100 0.634645 0.116233
|
||||
v 0.226180 1.482640 0.390559
|
||||
v 0.226180 0.634645 0.390559
|
||||
v -0.116233 1.482640 0.436100
|
||||
v -0.116233 0.634645 0.436100
|
||||
v -0.390559 1.482640 0.226180
|
||||
v -0.390559 0.634645 0.226180
|
||||
v -0.436100 1.482640 -0.116233
|
||||
v -0.436100 0.634645 -0.116233
|
||||
v -0.226180 1.482640 -0.390559
|
||||
v -0.226180 0.634645 -0.390559
|
||||
v 0.108975 0.634645 -0.430778
|
||||
v 0.292266 0.634645 -0.180802
|
||||
v 0.292266 1.482640 -0.180802
|
||||
v 0.108975 1.482640 -0.430778
|
||||
v 0.381664 0.634645 -0.227549
|
||||
v 0.334509 0.634645 0.078817
|
||||
v 0.334509 1.482640 0.078817
|
||||
v 0.381664 1.482640 -0.227549
|
||||
v 0.430778 0.634645 0.108975
|
||||
v 0.180802 0.634645 0.292266
|
||||
v 0.180802 1.482640 0.292266
|
||||
v 0.430778 1.482640 0.108975
|
||||
v 0.227549 0.634645 0.381664
|
||||
v -0.078817 0.634645 0.334509
|
||||
v -0.078817 1.482640 0.334509
|
||||
v 0.227549 1.482640 0.381664
|
||||
v -0.108975 0.634645 0.430778
|
||||
v -0.292266 0.634645 0.180802
|
||||
v -0.292266 1.482640 0.180802
|
||||
v -0.108975 1.482640 0.430778
|
||||
v -0.381664 0.634645 0.227549
|
||||
v -0.334509 0.634645 -0.078817
|
||||
v -0.334509 1.482640 -0.078817
|
||||
v -0.381664 1.482640 0.227549
|
||||
v -0.227549 0.634645 -0.381663
|
||||
v 0.078817 0.634645 -0.334509
|
||||
v 0.078817 1.482640 -0.334509
|
||||
v -0.227549 1.482640 -0.381663
|
||||
v -0.430779 0.634645 -0.108975
|
||||
v -0.180802 0.634645 -0.292266
|
||||
v -0.180802 1.482640 -0.292266
|
||||
v -0.430779 1.482640 -0.108975
|
||||
v 0.097545 1.500000 -0.490393
|
||||
v -0.097545 1.500000 -0.490393
|
||||
v -0.277785 1.500000 -0.415735
|
||||
v -0.415735 1.500000 -0.277785
|
||||
v -0.490393 1.500000 -0.097545
|
||||
v -0.490393 1.500000 0.097545
|
||||
v -0.415735 1.500000 0.277785
|
||||
v -0.277785 1.500000 0.415735
|
||||
v -0.097545 1.500000 0.490393
|
||||
v 0.097545 1.500000 0.490393
|
||||
v 0.277785 1.500000 0.415735
|
||||
v 0.415735 1.500000 0.277785
|
||||
v 0.490393 1.500000 0.097545
|
||||
v 0.490393 1.500000 -0.097545
|
||||
v 0.415735 1.500000 -0.277785
|
||||
v 0.277785 1.500000 -0.415735
|
||||
v 0.097545 1.468750 -0.490393
|
||||
v -0.097545 1.468750 -0.490393
|
||||
v -0.277785 1.468750 -0.415735
|
||||
v -0.415735 1.468750 -0.277785
|
||||
v -0.490393 1.468750 -0.097545
|
||||
v -0.490393 1.468750 0.097545
|
||||
v -0.415735 1.468750 0.277785
|
||||
v -0.277785 1.468750 0.415735
|
||||
v -0.097545 1.468750 0.490393
|
||||
v 0.097545 1.468750 0.490393
|
||||
v 0.277785 1.468750 0.415735
|
||||
v 0.415735 1.468750 0.277785
|
||||
v 0.490393 1.468750 0.097545
|
||||
v 0.490393 1.468750 -0.097545
|
||||
v 0.415735 1.468750 -0.277785
|
||||
v 0.277785 1.468750 -0.415735
|
||||
v 0.025624 0.559630 -0.061863
|
||||
v 0.025624 1.481372 -0.061863
|
||||
v 0.061863 0.559630 -0.025624
|
||||
v 0.061863 1.481372 -0.025624
|
||||
v 0.061863 0.559630 0.025624
|
||||
v 0.061863 1.481372 0.025624
|
||||
v 0.025624 0.559630 0.061863
|
||||
v 0.025624 1.481372 0.061863
|
||||
v -0.025624 0.559630 0.061863
|
||||
v -0.025624 1.481372 0.061863
|
||||
v -0.061863 0.559630 0.025624
|
||||
v -0.061863 1.481372 0.025624
|
||||
v -0.061863 0.559630 -0.025624
|
||||
v -0.061863 1.481372 -0.025624
|
||||
v -0.025624 0.559630 -0.061863
|
||||
v -0.025624 1.481372 -0.061863
|
||||
v 0.499775 -0.499550 -0.499775
|
||||
v 0.499775 -0.499550 0.499775
|
||||
v -0.499775 -0.499550 0.499775
|
||||
v -0.499775 -0.499550 -0.499775
|
||||
v 0.499775 0.500000 -0.499775
|
||||
v 0.499775 0.500000 0.499775
|
||||
v -0.499775 0.500000 0.499775
|
||||
v -0.499775 0.500000 -0.499775
|
||||
vt 1.000000 0.000000
|
||||
vt 1.000000 1.000000
|
||||
vt 0.000000 1.000000
|
||||
vt 0.000000 0.000000
|
||||
vt 0.400544 1.000000
|
||||
vt 0.599456 1.000000
|
||||
vt 0.783227 0.923880
|
||||
vt 0.923880 0.783227
|
||||
vt 1.000000 0.599456
|
||||
vt 1.000000 0.400544
|
||||
vt 0.923880 0.216773
|
||||
vt 0.783227 0.076120
|
||||
vt 0.599456 0.000000
|
||||
vt 0.400544 0.000000
|
||||
vt 0.216773 0.076121
|
||||
vt 0.076120 0.216773
|
||||
vt 0.000000 0.400544
|
||||
vt 0.000000 0.599456
|
||||
vt 0.076121 0.783227
|
||||
vt 0.216773 0.923880
|
||||
vt 0.500000 0.343750
|
||||
vt 0.531250 0.343750
|
||||
vt 0.531250 0.375000
|
||||
vt 0.500000 0.375000
|
||||
vt 0.531250 0.406250
|
||||
vt 0.500000 0.406250
|
||||
vt 0.500000 0.531250
|
||||
vt 0.531250 0.531250
|
||||
vt 0.531250 0.500000
|
||||
vt 0.500000 0.500000
|
||||
vt 0.531250 0.468750
|
||||
vt 0.500000 0.468750
|
||||
vt 0.531250 0.437500
|
||||
vt 0.500000 0.437500
|
||||
vt 0.593750 0.468750
|
||||
vt 0.625000 0.437500
|
||||
vt 0.656250 0.437500
|
||||
vt 0.687500 0.468750
|
||||
vt 0.687500 0.500000
|
||||
vt 0.656250 0.531250
|
||||
vt 0.625000 0.531250
|
||||
vt 0.593750 0.500000
|
||||
vt 0.500000 0.312500
|
||||
vt 0.531250 0.312500
|
||||
vt 0.500000 0.281250
|
||||
vt 0.531250 0.281250
|
||||
vt 0.156250 0.750000
|
||||
vt 0.156250 0.875000
|
||||
vt 0.125000 0.875000
|
||||
vt 0.125000 0.750000
|
||||
vt 0.156250 0.625000
|
||||
vt 0.125000 0.625000
|
||||
vt 0.156250 0.500000
|
||||
vt 0.125000 0.500000
|
||||
vt 0.156250 0.375000
|
||||
vt 0.125000 0.375000
|
||||
vt 0.156250 0.250000
|
||||
vt 0.125000 0.250000
|
||||
vt 0.250000 0.500000
|
||||
vt 0.250000 0.625000
|
||||
vt 0.218750 0.625000
|
||||
vt 0.218750 0.500000
|
||||
vt 0.156250 0.125000
|
||||
vt 0.125000 0.125000
|
||||
vt 0.156250 -0.000000
|
||||
vt 0.125000 -0.000000
|
||||
vt 0.250000 0.375000
|
||||
vt 0.218750 0.375000
|
||||
vt 0.250000 0.875000
|
||||
vt 0.250000 1.000000
|
||||
vt 0.218750 1.000000
|
||||
vt 0.218750 0.875000
|
||||
vt 0.250000 0.250000
|
||||
vt 0.218750 0.250000
|
||||
vt 0.250000 0.750000
|
||||
vt 0.218750 0.750000
|
||||
vt 0.250000 0.125000
|
||||
vt 0.218750 0.125000
|
||||
vt 0.250000 -0.000000
|
||||
vt 0.218750 -0.000000
|
||||
vt 0.156250 1.000000
|
||||
vt 0.125000 1.000000
|
||||
vt 0.781250 0.593750
|
||||
vt 0.781250 0.968750
|
||||
vt 0.656250 0.968750
|
||||
vt 0.656250 0.593750
|
||||
vt 0.625000 0.593750
|
||||
vt 0.625000 0.968750
|
||||
vt 0.500000 0.968750
|
||||
vt 0.500000 0.593750
|
||||
vt 0.406250 -0.000000
|
||||
vt 0.437500 -0.000000
|
||||
vt 0.437500 0.125000
|
||||
vt 0.406250 0.125000
|
||||
vt 0.312500 0.875000
|
||||
vt 0.343750 0.875000
|
||||
vt 0.343750 1.000000
|
||||
vt 0.312500 1.000000
|
||||
vt 0.312500 0.750000
|
||||
vt 0.343750 0.750000
|
||||
vt 0.312500 0.625000
|
||||
vt 0.343750 0.625000
|
||||
vt 0.312500 0.500000
|
||||
vt 0.343750 0.500000
|
||||
vt 0.406250 0.750000
|
||||
vt 0.437500 0.750000
|
||||
vt 0.437500 0.875000
|
||||
vt 0.406250 0.875000
|
||||
vt 0.312500 0.375000
|
||||
vt 0.343750 0.375000
|
||||
vt 0.312500 0.250000
|
||||
vt 0.343750 0.250000
|
||||
vt 0.406250 0.625000
|
||||
vt 0.437500 0.625000
|
||||
vt 0.312500 0.125000
|
||||
vt 0.343750 0.125000
|
||||
vt 0.406250 0.500000
|
||||
vt 0.437500 0.500000
|
||||
vt 0.312500 -0.000000
|
||||
vt 0.343750 -0.000000
|
||||
vt 0.406250 0.375000
|
||||
vt 0.437500 0.375000
|
||||
vt 0.437500 1.000000
|
||||
vt 0.406250 1.000000
|
||||
vt 0.406250 0.250000
|
||||
vt 0.437500 0.250000
|
||||
vt 0.031250 0.937500
|
||||
vt 0.062500 0.937500
|
||||
vt 0.062500 0.968750
|
||||
vt 0.031250 0.968750
|
||||
vt 0.031250 0.718750
|
||||
vt 0.062500 0.718750
|
||||
vt 0.062500 0.750000
|
||||
vt 0.031250 0.750000
|
||||
vt 0.062500 0.781250
|
||||
vt 0.031250 0.781250
|
||||
vt 0.062500 0.812500
|
||||
vt 0.031250 0.812500
|
||||
vt 0.062500 0.843750
|
||||
vt 0.031250 0.843750
|
||||
vt 0.062500 0.875000
|
||||
vt 0.031250 0.875000
|
||||
vt 0.031250 0.906250
|
||||
vt 0.062500 0.906250
|
||||
vn 1.000000 0.000000 0.000000
|
||||
vn -0.000000 -0.000000 1.000000
|
||||
vn -1.000000 -0.000000 -0.000000
|
||||
vn 0.000000 0.000000 -1.000000
|
||||
vn 0.000000 -1.000000 -0.000000
|
||||
vn 0.000000 1.000000 0.000000
|
||||
vn 0.382700 0.000000 -0.923900
|
||||
vn 0.923900 0.000000 -0.382700
|
||||
vn 0.923900 0.000000 0.382700
|
||||
vn 0.382700 0.000000 0.923900
|
||||
vn -0.382700 0.000000 0.923900
|
||||
vn -0.923900 0.000000 0.382700
|
||||
vn -0.382700 0.000000 -0.923900
|
||||
vn -0.923900 0.000000 -0.382700
|
||||
vn 0.707100 0.000000 0.707100
|
||||
vn -0.707100 0.000000 0.707100
|
||||
vn 0.707100 0.000000 -0.707100
|
||||
vn -0.707100 0.000000 -0.707100
|
||||
vn 0.806400 0.000000 -0.591300
|
||||
vn 0.988400 0.000000 0.152100
|
||||
vn 0.591300 0.000000 0.806400
|
||||
vn -0.152100 0.000000 0.988400
|
||||
vn -0.806400 0.000000 0.591300
|
||||
vn -0.988400 0.000000 -0.152100
|
||||
vn 0.152100 0.000000 -0.988400
|
||||
vn -0.591300 0.000000 -0.806400
|
||||
g Cylinder.002_Cylinder.003_sides
|
||||
s off
|
||||
f 161/1/1 165/2/1 166/3/1 162/4/1
|
||||
f 162/1/2 166/2/2 167/3/2 163/4/2
|
||||
f 163/4/3 167/3/3 168/2/3 164/1/3
|
||||
f 165/2/4 161/1/4 164/4/4 168/3/4
|
||||
g Cylinder.002_Cylinder.003_top-bottom
|
||||
f 161/2/5 162/1/5 163/4/5 164/3/5
|
||||
f 165/2/6 168/3/6 167/4/6 166/1/6
|
||||
g Cylinder.002_Cylinder.003_turbine-top-bottom
|
||||
f 130/5/5 129/6/5 144/7/5 143/8/5 142/9/5 141/10/5 140/11/5 139/12/5 138/13/5 137/14/5 136/15/5 135/16/5 134/17/5 133/18/5 132/19/5 131/20/5
|
||||
f 18/5/5 17/6/5 32/7/5 31/8/5 30/9/5 29/10/5 28/11/5 27/12/5 26/13/5 25/14/5 24/15/5 23/16/5 22/17/5 21/18/5 20/19/5 19/20/5
|
||||
f 33/6/6 34/5/6 35/20/6 36/19/6 37/18/6 38/17/6 39/16/6 40/15/6 41/14/6 42/13/6 43/12/6 44/11/6 45/10/6 46/9/6 47/8/6 48/7/6
|
||||
f 113/6/6 114/5/6 115/20/6 116/19/6 117/18/6 118/17/6 119/16/6 120/15/6 121/14/6 122/13/6 123/12/6 124/11/6 125/10/6 126/9/6 127/8/6 128/7/6
|
||||
g Cylinder.002_Cylinder.003_turbine-blades-etc
|
||||
f 1/21/7 2/22/7 4/23/7 3/24/7
|
||||
f 3/24/8 4/23/8 6/25/8 5/26/8
|
||||
f 5/27/9 6/28/9 8/29/9 7/30/9
|
||||
f 7/30/10 8/29/10 10/31/10 9/32/10
|
||||
f 9/32/11 10/31/11 12/33/11 11/34/11
|
||||
f 11/34/12 12/33/12 14/25/12 13/26/12
|
||||
f 4/35/6 2/36/6 16/37/6 14/38/6 12/39/6 10/40/6 8/41/6 6/42/6
|
||||
f 15/43/13 16/44/13 2/22/13 1/21/13
|
||||
f 13/45/14 14/46/14 16/44/14 15/43/14
|
||||
f 27/47/15 28/48/15 44/49/15 43/50/15
|
||||
f 26/51/10 27/47/10 43/50/10 42/52/10
|
||||
f 25/53/2 26/51/2 42/52/2 41/54/2
|
||||
f 24/55/11 25/53/11 41/54/11 40/56/11
|
||||
f 23/57/16 24/55/16 40/56/16 39/58/16
|
||||
f 17/59/4 18/60/4 34/61/4 33/62/4
|
||||
f 22/63/12 23/57/12 39/58/12 38/64/12
|
||||
f 21/65/3 22/63/3 38/64/3 37/66/3
|
||||
f 32/67/7 17/59/7 33/62/7 48/68/7
|
||||
f 20/69/14 21/70/14 37/71/14 36/72/14
|
||||
f 31/73/17 32/67/17 48/68/17 47/74/17
|
||||
f 19/75/18 20/69/18 36/72/18 35/76/18
|
||||
f 30/77/8 31/73/8 47/74/8 46/78/8
|
||||
f 18/60/13 19/75/13 35/76/13 34/61/13
|
||||
f 29/79/1 30/77/1 46/78/1 45/80/1
|
||||
f 28/48/9 29/81/9 45/82/9 44/49/9
|
||||
f 49/83/19 50/84/19 52/85/19 51/86/19
|
||||
f 68/86/20 67/83/20 54/84/20 53/85/20
|
||||
f 70/83/21 69/84/21 56/85/21 55/86/21
|
||||
f 72/84/22 71/85/22 58/86/22 57/83/22
|
||||
f 74/83/23 73/84/23 60/85/23 59/86/23
|
||||
f 76/83/24 75/84/24 62/85/24 61/86/24
|
||||
f 80/84/25 79/85/25 66/86/25 65/83/25
|
||||
f 78/83/26 77/84/26 64/85/26 63/86/26
|
||||
f 81/87/23 82/88/23 83/89/23 84/90/23
|
||||
f 85/88/24 86/89/24 87/90/24 88/87/24
|
||||
f 89/89/26 90/90/26 91/87/26 92/88/26
|
||||
f 93/90/25 94/87/25 95/88/25 96/89/25
|
||||
f 97/90/19 98/87/19 99/88/19 100/89/19
|
||||
f 101/87/20 102/88/20 103/89/20 104/90/20
|
||||
f 105/90/22 106/87/22 107/88/22 108/89/22
|
||||
f 109/89/21 110/90/21 111/87/21 112/88/21
|
||||
f 75/88/22 76/87/22 101/86/22 104/85/22
|
||||
f 71/88/20 72/87/20 93/86/20 96/85/20
|
||||
f 67/86/25 68/85/25 85/88/25 88/87/25
|
||||
f 79/86/24 80/85/24 105/88/24 108/87/24
|
||||
f 77/88/23 78/87/23 109/86/23 112/85/23
|
||||
f 73/88/21 74/87/21 97/86/21 100/85/21
|
||||
f 69/86/19 70/85/19 89/88/19 92/87/19
|
||||
f 50/86/26 49/85/26 81/88/26 84/87/26
|
||||
f 123/91/15 139/92/15 140/93/15 124/94/15
|
||||
f 122/95/10 138/96/10 139/97/10 123/98/10
|
||||
f 121/99/2 137/100/2 138/96/2 122/95/2
|
||||
f 120/101/11 136/102/11 137/100/11 121/99/11
|
||||
f 119/103/16 135/104/16 136/102/16 120/101/16
|
||||
f 113/105/4 129/106/4 130/107/4 114/108/4
|
||||
f 118/109/12 134/110/12 135/104/12 119/103/12
|
||||
f 117/111/3 133/112/3 134/110/3 118/109/3
|
||||
f 128/113/7 144/114/7 129/106/7 113/105/7
|
||||
f 116/115/14 132/116/14 133/112/14 117/111/14
|
||||
f 127/117/17 143/118/17 144/114/17 128/113/17
|
||||
f 115/119/18 131/120/18 132/116/18 116/115/18
|
||||
f 126/121/8 142/122/8 143/118/8 127/117/8
|
||||
f 114/108/13 130/107/13 131/123/13 115/124/13
|
||||
f 125/125/1 141/126/1 142/122/1 126/121/1
|
||||
f 124/94/9 140/93/9 141/126/9 125/125/9
|
||||
f 145/127/17 146/128/17 148/129/17 147/130/17
|
||||
f 147/131/1 148/132/1 150/133/1 149/134/1
|
||||
f 149/134/15 150/133/15 152/135/15 151/136/15
|
||||
f 151/136/2 152/135/2 154/137/2 153/138/2
|
||||
f 153/138/16 154/137/16 156/139/16 155/140/16
|
||||
f 155/140/3 156/139/3 158/141/3 157/142/3
|
||||
f 159/143/4 160/144/4 146/128/4 145/127/4
|
||||
f 157/142/18 158/141/18 160/144/18 159/143/18
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 4.8 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 782 B |
Binary file not shown.
|
Before Width: | Height: | Size: 758 B |
Binary file not shown.
|
Before Width: | Height: | Size: 564 B |
Binary file not shown.
|
Before Width: | Height: | Size: 820 B |
Binary file not shown.
|
Before Width: | Height: | Size: 496 B |
@ -1 +0,0 @@
|
||||
Insulated mesecons are conductors that only conduct in one direction (and also not up or down).
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user