From 91e44ae813c3ed29ea52d96c36eed9f532098e4f Mon Sep 17 00:00:00 2001 From: LeMagnesium Date: Sun, 8 Mar 2015 15:22:06 +0100 Subject: [PATCH] Updated pipeworks (rollback) --- mods/pipeworks/devices.lua | 85 +++++-- mods/pipeworks/flowing_logic.lua | 415 +++++++------------------------ mods/pipeworks/init.lua | 18 +- mods/pipeworks/pipes.lua | 54 +++- mods/pipeworks/vacuum_tubes.lua | 2 +- 5 files changed, 209 insertions(+), 365 deletions(-) diff --git a/mods/pipeworks/devices.lua b/mods/pipeworks/devices.lua index 1ba95117..89806d9f 100644 --- a/mods/pipeworks/devices.lua +++ b/mods/pipeworks/devices.lua @@ -107,15 +107,15 @@ for s in ipairs(states) do drop = "pipeworks:valve_off_empty", mesecons = {effector = { action_on = function (pos, node) - minetest.swap_node(pos,{name="pipeworks:valve_on_empty", param2 = node.param2}) + minetest.add_node(pos,{name="pipeworks:valve_on_empty", param2 = node.param2}) end, action_off = function (pos, node) - minetest.swap_node(pos,{name="pipeworks:valve_off_empty", param2 = node.param2}) + minetest.add_node(pos,{name="pipeworks:valve_off_empty", param2 = node.param2}) end }}, on_punch = function(pos, node, puncher) local fdir = minetest.get_node(pos).param2 - minetest.swap_node(pos, { name = "pipeworks:valve_"..states[3-s].."_empty", param2 = fdir }) + minetest.add_node(pos, { name = "pipeworks:valve_"..states[3-s].."_empty", param2 = fdir }) end }) end @@ -148,15 +148,15 @@ minetest.register_node("pipeworks:valve_on_loaded", { drop = "pipeworks:valve_off_empty", mesecons = {effector = { action_on = function (pos, node) - minetest.swap_node(pos,{name="pipeworks:valve_on_empty", param2 = node.param2}) + minetest.add_node(pos,{name="pipeworks:valve_on_empty", param2 = node.param2}) end, action_off = function (pos, node) - minetest.swap_node(pos,{name="pipeworks:valve_off_empty", param2 = node.param2}) + minetest.add_node(pos,{name="pipeworks:valve_off_empty", param2 = node.param2}) end }}, on_punch = function(pos, node, puncher) local fdir = minetest.get_node(pos).param2 - minetest.swap_node(pos, { name = "pipeworks:valve_off_empty", param2 = fdir }) + minetest.add_node(pos, { name = "pipeworks:valve_off_empty", param2 = fdir }) end }) @@ -241,11 +241,6 @@ minetest.register_node("pipeworks:spigot_pouring", { end, after_dig_node = function(pos) pipeworks.scan_for_pipe_objects(pos) - local pos_below = {x = pos.x, y = pos.y-1, z = pos.z} - local below_node = minetest.get_node(pos_below) - if below_node.name == "default:water_source" then - minetest.set_node(pos_below, { name = "air" }) - end end, selection_box = { type = "fixed", @@ -269,7 +264,7 @@ local panel_cbox = { } } -minetest.register_node("pipeworks:entry_panel", { +minetest.register_node("pipeworks:entry_panel_empty", { description = "Airtight Pipe entry/exit", drawtype = "mesh", mesh = "pipeworks_entry_panel.obj", @@ -325,7 +320,7 @@ minetest.register_node("pipeworks:entry_panel", { if not minetest.registered_nodes[minetest.get_node(pos1).name]["buildable_to"] then return end - minetest.add_node(pos1, {name = "pipeworks:entry_panel", param2 = fdir }) + minetest.add_node(pos1, {name = "pipeworks:entry_panel_empty", param2 = fdir }) pipeworks.scan_for_pipe_objects(pos1) if not pipeworks.expect_infinite_stacks then @@ -340,10 +335,26 @@ minetest.register_node("pipeworks:entry_panel", { end }) -local sensorboxes = {} -pipeworks.add_node_box(sensorboxes, pipeworks.pipe_leftstub) -pipeworks.add_node_box(sensorboxes, pipeworks.pipe_sensorbody) -pipeworks.add_node_box(sensorboxes, pipeworks.pipe_rightstub) +minetest.register_node("pipeworks:entry_panel_loaded", { + description = "Airtight Pipe entry/exit", + drawtype = "mesh", + mesh = "pipeworks_entry_panel.obj", + tiles = { "pipeworks_entry_panel.png" }, + paramtype = "light", + paramtype2 = "facedir", + groups = {snappy=3, pipe=1, not_in_creative_inventory=1}, + sounds = default.node_sound_wood_defaults(), + walkable = true, + after_place_node = function(pos) + pipeworks.scan_for_pipe_objects(pos) + end, + after_dig_node = function(pos) + pipeworks.scan_for_pipe_objects(pos) + end, + selection_box = panel_cbox, + collision_box = panel_cbox, + drop = "pipeworks:entry_panel_empty" +}) minetest.register_node("pipeworks:flow_sensor_empty", { description = "Flow Sensor", @@ -507,11 +518,6 @@ minetest.register_node("pipeworks:fountainhead", { end, after_dig_node = function(pos) pipeworks.scan_for_pipe_objects(pos) - local pos_above = {x = pos.x, y = pos.y+1, z = pos.z} - local node_above = minetest.get_node(pos_above) - if node_above.name == "default:water_source" then - minetest.set_node(pos_above, { name = "air" }) - end end, on_construct = function(pos) if mesecon then @@ -528,10 +534,37 @@ minetest.register_node("pipeworks:fountainhead", { }, }) --- compatibility +minetest.register_node("pipeworks:fountainhead_pouring", { + description = "Fountainhead", + drawtype = "mesh", + mesh = "pipeworks_fountainhead.obj", + tiles = { "pipeworks_fountainhead.png" }, + sunlight_propagates = true, + paramtype = "light", + groups = {snappy=3, pipe=1, not_in_creative_inventory=1}, + sounds = default.node_sound_wood_defaults(), + walkable = true, + after_place_node = function(pos) + pipeworks.scan_for_pipe_objects(pos) + end, + after_dig_node = function(pos) + pipeworks.scan_for_pipe_objects(pos) + end, + on_construct = function(pos) + if mesecon then + mesecon.receptor_on(pos, rules) + end + end, + selection_box = { + type = "fixed", + fixed = { -2/16, -8/16, -2/16, 2/16, 8/16, 2/16 } + }, + collision_box = { + type = "fixed", + fixed = { -2/16, -8/16, -2/16, 2/16, 8/16, 2/16 } + }, + drop = "pipeworks:fountainhead" +}) minetest.register_alias("pipeworks:valve_off_loaded", "pipeworks:valve_off_empty") -minetest.register_alias("pipeworks:fountainhead_pouring", "pipeworks:fountainhead") -minetest.register_alias("pipeworks:entry_panel_empty", "pipeworks:entry_panel") -minetest.register_alias("pipeworks:entry_panel_loaded", "pipeworks:entry_panel") diff --git a/mods/pipeworks/flowing_logic.lua b/mods/pipeworks/flowing_logic.lua index 7bc3e78f..e0a6236d 100644 --- a/mods/pipeworks/flowing_logic.lua +++ b/mods/pipeworks/flowing_logic.lua @@ -1,344 +1,121 @@ --- This file provides the actual flow logic that makes liquids +-- This file provides the actual flow and pathfinding logic that makes water -- move through the pipes. +-- +-- Contributed by mauvebic, 2013-01-03, rewritten a bit by Vanessa Ezekowitz +-- -local finite_liquids = minetest.setting_getbool("liquid_finite") -local pipe_liquid_shows_loaded = 1 -local max_pressure = 4 +local finitewater = minetest.setting_getbool("liquid_finite") -if mesecon then - pipereceptor_on = { - receptor = { - state = mesecon.state.on, - rules = pipeworks.mesecons_rules - } - } - - pipereceptor_off = { - receptor = { - state = mesecon.state.off, - rules = pipeworks.mesecons_rules - } - } +pipeworks.check_for_liquids = function(pos) + local coords = { + {x=pos.x,y=pos.y-1,z=pos.z}, + {x=pos.x,y=pos.y+1,z=pos.z}, + {x=pos.x-1,y=pos.y,z=pos.z}, + {x=pos.x+1,y=pos.y,z=pos.z}, + {x=pos.x,y=pos.y,z=pos.z-1}, + {x=pos.x,y=pos.y,z=pos.z+1}, } + for i =1,6 do + local name = minetest.get_node(coords[i]).name + if name and string.find(name,"water") then + if finitewater then minetest.remove_node(coords[i]) end + return true + end + end + return false end --- check if a valve, sensor, or other X-oriented device --- has something connected at each end. - -function pipeworks.is_device_connected(pos, node, axisdir, fdir_mod4, rotation) - local fdir = node.param2 - local fdir_mod4_p2 = (fdir+2) % 4 - - if rotation == "z" then - fdir_mod4 = (fdir+1) % 4 - fdir_mod4_p2 = (fdir+3) % 4 +pipeworks.check_for_inflows = function(pos,node) + local coords = { + {x=pos.x,y=pos.y-1,z=pos.z}, + {x=pos.x,y=pos.y+1,z=pos.z}, + {x=pos.x-1,y=pos.y,z=pos.z}, + {x=pos.x+1,y=pos.y,z=pos.z}, + {x=pos.x,y=pos.y,z=pos.z-1}, + {x=pos.x,y=pos.y,z=pos.z+1}, } + local newnode = false + local source = false + for i =1,6 do + if newnode then break end + local name = minetest.get_node(coords[i]).name + if name and (name == "pipeworks:pump_on" and pipeworks.check_for_liquids(coords[i])) or string.find(name,"_loaded") then + if string.find(name,"_loaded") then + source = minetest.get_meta(coords[i]):get_string("source") + if source == minetest.pos_to_string(pos) then break end + end + newnode = string.gsub(node.name,"empty","loaded") + source = {x=coords[i].x,y=coords[i].y,z=coords[i].z} + end end - - local fdir_to_pos = { - {x = pos.x+1, y = pos.y, z = pos.z }, - {x = pos.x, y = pos.y, z = pos.z-1}, - {x = pos.x-1, y = pos.y, z = pos.z }, - {x = pos.x, y = pos.y, z = pos.z+1}, - } - - local pos_adjacent1 = fdir_to_pos[fdir_mod4 + 1] - local pos_adjacent2 = fdir_to_pos[fdir_mod4_p2 + 1] - - if rotation == "y" then - pos_adjacent1 = { x=pos.x, y=pos.y+1, z=pos.z } - pos_adjacent2 = { x=pos.x, y=pos.y-1, z=pos.z } + if newnode then + minetest.add_node(pos,{name=newnode, param2 = node.param2}) + minetest.get_meta(pos):set_string("source",minetest.pos_to_string(source)) end - - local adjacent_node1 = minetest.get_node(pos_adjacent1) - local adjacent_node2 = minetest.get_node(pos_adjacent2) - - local set1 - local set2 - - if string.find(dump(pipeworks.pipe_nodenames), adjacent_node1.name) or - (string.find(dump(pipeworks.device_nodenames), adjacent_node1.name) and - (adjacent_node1.param2 == fdir_mod4 or adjacent_node1.param2 == fdir_mod4_p2)) then - set1 = true - end - - if string.find(dump(pipeworks.pipe_nodenames), adjacent_node2.name) or - (string.find(dump(pipeworks.device_nodenames), adjacent_node2.name) and - (adjacent_node2.param2 == fdir_mod4 or adjacent_node2.param2 == fdir_mod4_p2)) then - set2 = true - end - return {set1=set1, set2=set2, pos_adjacent1=pos_adjacent1, pos_adjacent2=pos_adjacent2} end --- Evaluate and balance liquid in all pipes +pipeworks.check_sources = function(pos,node) + local sourcepos = minetest.string_to_pos(minetest.get_meta(pos):get_string("source")) + if not sourcepos then return end + local source = minetest.get_node(sourcepos).name + local newnode = false + if source and not ((source == "pipeworks:pump_on" and pipeworks.check_for_liquids(sourcepos)) or string.find(source,"_loaded") or source == "ignore" ) then + newnode = string.gsub(node.name,"loaded","empty") + end -minetest.register_abm({ - label = "Liquid balancing", - nodenames = pipeworks.pipe_nodenames, - interval = 1, - chance = 1, - action = function(pos, node, active_object_count, active_object_count_wider) - local coords = { - {x = pos.x, y = pos.y, z = pos.z}, - {x = pos.x, y = pos.y-1, z = pos.z}, - {x = pos.x, y = pos.y+1, z = pos.z}, - {x = pos.x-1, y = pos.y, z = pos.z}, - {x = pos.x+1, y = pos.y, z = pos.z}, - {x = pos.x, y = pos.y, z = pos.z-1}, - {x = pos.x, y = pos.y, z = pos.z+1}, + if newnode then + minetest.add_node(pos,{name=newnode, param2 = node.param2}) + minetest.get_meta(pos):set_string("source","") + end +end + +pipeworks.spigot_check = function(pos, node) + local belowname = minetest.get_node({x=pos.x,y=pos.y-1,z=pos.z}).name + if belowname and (belowname == "air" or belowname == "default:water_flowing" or belowname == "default:water_source") then + local spigotname = minetest.get_node(pos).name + local fdir=node.param2 + local check = { + {x=pos.x,y=pos.y,z=pos.z+1}, + {x=pos.x+1,y=pos.y,z=pos.z}, + {x=pos.x,y=pos.y,z=pos.z-1}, + {x=pos.x-1,y=pos.y,z=pos.z} } - - local num_connections = 0 - local connection_list = {} - local total_level = 0 - - for _,adjacentpos in ipairs(coords) do - local adjacent_node = minetest.get_node(adjacentpos) - if adjacent_node and string.find(dump(pipeworks.pipe_nodenames), adjacent_node.name) then - - local node_level = (minetest.get_meta(adjacentpos):get_float("liquid_level")) or 0 - if node_level < 0 then node_level = 0 end - - total_level = total_level + node_level - num_connections = num_connections + 1 - table.insert(connection_list, adjacentpos) - end - end - - local average_level = total_level / num_connections - - for _, connected_pipe_pos in ipairs(connection_list) do - - local newnode - local connected_pipe = minetest.get_node(connected_pipe_pos) - local pipe_name = string.match(connected_pipe.name, "pipeworks:pipe_%d.*_") - - if connected_pipe and pipe_name then - minetest.get_meta(connected_pipe_pos):set_float("liquid_level", average_level) - - if average_level > pipe_liquid_shows_loaded then - newnode = pipe_name.."loaded" - else - newnode = pipe_name.."empty" + local near_node = minetest.get_node(check[fdir+1]) + if near_node and string.find(near_node.name, "_loaded") then + if spigotname and spigotname == "pipeworks:spigot" then + minetest.add_node(pos,{name = "pipeworks:spigot_pouring", param2 = fdir}) + if finitewater or belowname ~= "default:water_source" then + minetest.add_node({x=pos.x,y=pos.y-1,z=pos.z},{name = "default:water_source"}) end end - - if newnode and connected_pipe.name ~= newnode then - minetest.swap_node(connected_pipe_pos, {name = newnode, param2 = connected_pipe.param2}) - end - end - end -}) - --- Process all pumps in the area - -minetest.register_abm({ - label = "Pump processing", - nodenames = {"pipeworks:pump_on", "pipeworks:pump_off"}, - interval = 1, - chance = 1, - action = function(pos, node, active_object_count, active_object_count_wider) - local minp = {x = pos.x-1, y = pos.y-1, z = pos.z-1} - local maxp = {x = pos.x+1, y = pos.y, z = pos.z+1} - local pos_above = {x = pos.x, y = pos.y+1, z = pos.z} - local node_above = minetest.get_node(pos_above) - if not node_above then return end - - local meta = minetest.get_meta(pos_above) - local node_level_above = meta:get_float("liquid_level") - if node_level_above == nil then node_level_above = 0 end - local pipe_name = string.match(node_above.name, "pipeworks:pipe_%d.*_") - - if pipe_name then - if node.name == "pipeworks:pump_on" then - local water_nodes = minetest.find_nodes_in_area(minp, maxp, - {"default:water_source", "default:water_flowing"}) - - if (node_level_above < max_pressure ) and #water_nodes > 1 then - meta:set_float("liquid_level", node_level_above + 4) -- add water to the pipe - end - else - if node_level_above > 0 then - meta:set_float("liquid_level", node_level_above - 0.5 ) -- leak the pipe down - end - end - end - end -}) - --- Process all spigots and fountainheads in the area - -minetest.register_abm({ - label = "Spigot/Fountainhead processing", - nodenames = {"pipeworks:spigot", "pipeworks:spigot_pouring", "pipeworks:fountainhead"}, - interval = 2, - chance = 1, - action = function(pos, node, active_object_count, active_object_count_wider) - - local fdir = node.param2 % 4 - if fdir ~= node.param2 then - minetest.set_node(pos,{name = node.name, param2 = fdir}) - end - - local pos_below = {x = pos.x, y = pos.y-1, z = pos.z} - local below_node = minetest.get_node(pos_below) - if not below_node then return end - - if node.name == "pipeworks:fountainhead" then - local pos_above = {x = pos.x, y = pos.y+1, z = pos.z} - local node_above = minetest.get_node(pos_above) - if not node_above then return end - - local node_level_below = (minetest.get_meta(pos_below):get_float("liquid_level")) or 0 - - if node_level_below > 1 - and (node_above.name == "air" or node_above.name == "default:water_flowing") then - minetest.set_node(pos_above, {name = "default:water_source"}) - elseif node_level_below < 0.95 and node_above.name == "default:water_source" then - minetest.set_node(pos_above, {name = "air"}) - end - - if node_level_below >= 1 - and (node_above.name == "air" or node_above.name == "default:water_source") then - minetest.get_meta(pos_below):set_float("liquid_level", node_level_below - 1) - end else - if below_node.name == "air" or below_node.name == "default:water_flowing" - or below_node.name == "default:water_source" then - - local fdir_to_pos = { - {x = pos.x, y = pos.y, z = pos.z+1}, - {x = pos.x+1, y = pos.y, z = pos.z }, - {x = pos.x, y = pos.y, z = pos.z-1}, - {x = pos.x-1, y = pos.y, z = pos.z } - } - - local pos_adjacent = fdir_to_pos[fdir+1] - local adjacent_node = minetest.get_node(pos_adjacent) - if not adjacent_node then return end - - local adjacent_node_level = (minetest.get_meta(pos_adjacent):get_float("liquid_level")) or 0 - local pipe_name = string.match(adjacent_node.name, "pipeworks:pipe_%d.*_") - - if pipe_name and adjacent_node_level > 1 - and (below_node.name == "air" or below_node.name == "default:water_flowing") then - minetest.set_node(pos, {name = "pipeworks:spigot_pouring", param2 = fdir}) - minetest.set_node(pos_below, {name = "default:water_source"}) - end - - if (pipe_name and adjacent_node_level < 0.95) - or (node.name ~= "pipeworks:spigot" and not pipe_name) then - minetest.set_node(pos,{name = "pipeworks:spigot", param2 = fdir}) - if below_node.name == "default:water_source" then - minetest.set_node(pos_below, {name = "air"}) - end - end - - if adjacent_node_level >= 1 - and (below_node.name == "air" or below_node.name == "default:water_source") then - minetest.get_meta(pos_adjacent):set_float("liquid_level", adjacent_node_level - 1) + if spigotname == "pipeworks:spigot_pouring" then + minetest.add_node({x=pos.x,y=pos.y,z=pos.z},{name = "pipeworks:spigot", param2 = fdir}) + if belowname == "default:water_source" and not finitewater then + minetest.remove_node({x=pos.x,y=pos.y-1,z=pos.z}) end end end end -}) +end -pipeworks.device_nodenames = {} - -table.insert(pipeworks.device_nodenames,"pipeworks:valve_on_empty") -table.insert(pipeworks.device_nodenames,"pipeworks:valve_off_empty") -table.insert(pipeworks.device_nodenames,"pipeworks:valve_on_loaded") -table.insert(pipeworks.device_nodenames,"pipeworks:flow_sensor_empty") -table.insert(pipeworks.device_nodenames,"pipeworks:flow_sensor_loaded") -table.insert(pipeworks.device_nodenames,"pipeworks:entry_panel") - -minetest.register_abm({ - label = "Waterdevices processing", - nodenames = pipeworks.device_nodenames, - interval = 2, - chance = 1, - action = function(pos, node, active_object_count, active_object_count_wider) - - local fdir = node.param2 - local axisdir = math.floor(fdir/4) - local fdir_mod4 = fdir % 4 - local rotation - - if not string.match(node.name, "pipeworks:valve_off") then - - if node.name == "pipeworks:entry_panel" then - rotation = "z" - fdir_mod4 = (fdir+1) % 4 - - -- reset the panel's facedir to predictable values, if needed - - if axisdir == 5 then - minetest.swap_node(pos, {name = node.name, param2 = fdir_mod4 }) - return - elseif axisdir ~= 0 and axisdir ~= 3 then - minetest.swap_node(pos, {name = node.name, param2 = 13 }) - return +pipeworks.fountainhead_check = function(pos, node) + local abovename = minetest.get_node({x=pos.x,y=pos.y+1,z=pos.z}).name + if abovename and (abovename == "air" or abovename == "default:water_flowing" or abovename == "default:water_source") then + local fountainhead_name = minetest.get_node(pos).name + local near_node = minetest.get_node({x=pos.x,y=pos.y-1,z=pos.z}) + if near_node and string.find(near_node.name, "_loaded") then + if fountainhead_name and fountainhead_name == "pipeworks:fountainhead" then + minetest.add_node(pos,{name = "pipeworks:fountainhead_pouring"}) + if finitewater or abovename ~= "default:water_source" then + minetest.add_node({x=pos.x,y=pos.y+1,z=pos.z},{name = "default:water_source"}) end - - if node.param2 == 13 then - rotation = "y" - end - elseif axisdir ~= 0 and axisdir ~= 5 then -- if the device isn't horizontal, force it. - minetest.swap_node(pos, {name = node.name, param2 = fdir_mod4}) - return end - - local connections = pipeworks.is_device_connected(pos, node, axisdir, fdir_mod4, rotation) - - local num_connections = 1 - local my_level = (minetest.get_meta(pos):get_float("liquid_level")) or 0 - local total_level = my_level - - if not connections.set1 and not connections.set2 then return end - - if connections.set1 then - num_connections = num_connections + 1 - total_level = total_level + (minetest.get_meta(connections.pos_adjacent1):get_float("liquid_level")) or 0 - end - - if connections.set2 then - num_connections = num_connections + 1 - total_level = total_level + (minetest.get_meta(connections.pos_adjacent2):get_float("liquid_level")) or 0 - end - - local average_level = total_level / num_connections - - minetest.get_meta(pos):set_float("liquid_level", average_level) - - if connections.set1 then - minetest.get_meta(connections.pos_adjacent1):set_float("liquid_level", average_level) - end - - if connections.set2 then - minetest.get_meta(connections.pos_adjacent2):set_float("liquid_level", average_level) - end - - if node.name == "pipeworks:flow_sensor_empty" or - node.name == "pipeworks:flow_sensor_loaded" then - local sensor = string.match(node.name, "pipeworks:flow_sensor_") - local newnode = nil - - if my_level > 1 and (connections.set1 or connections.set2) then - newnode = sensor.."loaded" - else - newnode = sensor.."empty" - end - - if newnode ~= node.name then - minetest.swap_node(pos, {name = newnode, param2 = node.param2}) - if mesecon then - if newnode == "pipeworks:flow_sensor_empty" then - mesecon.receptor_off(pos, rules) - else - mesecon.receptor_on(pos, rules) - end - end + else + if fountainhead_name == "pipeworks:fountainhead_pouring" then + minetest.add_node({x=pos.x,y=pos.y,z=pos.z},{name = "pipeworks:fountainhead"}) + if abovename == "default:water_source" and not finitewater then + minetest.remove_node({x=pos.x,y=pos.y+1,z=pos.z}) end end end end -}) - +end diff --git a/mods/pipeworks/init.lua b/mods/pipeworks/init.lua index 2bad6661..5ed4074f 100755 --- a/mods/pipeworks/init.lua +++ b/mods/pipeworks/init.lua @@ -39,8 +39,6 @@ pipeworks.mesecons_rules={{x=0,y=0,z=1},{x=0,y=0,z=-1},{x=1,y=0,z=0},{x=-1,y=0,z pipeworks.liquid_texture = "default_water.png" -pipeworks.pipe_nodenames = {} - -- Helper functions function pipeworks.fix_image_names(table, replacement) @@ -106,18 +104,6 @@ function pipeworks.replace_name(tbl,tr,name) return ntbl end -function pipeworks.table_copy(t) - local nt = { }; - for k, v in pairs(t) do - if type(v) == "table" then - nt[k] = pipeworks.table_copy(v) - else - nt[k] = v - end - end - return nt -end - ------------------------------------------- -- Load the various other parts of the mod @@ -127,10 +113,7 @@ dofile(pipeworks.modpath.."/autoplace_pipes.lua") dofile(pipeworks.modpath.."/autoplace_tubes.lua") dofile(pipeworks.modpath.."/luaentity.lua") dofile(pipeworks.modpath.."/item_transport.lua") - -if pipeworks.enable_pipes then dofile(pipeworks.modpath.."/pipes.lua") end dofile(pipeworks.modpath.."/flowing_logic.lua") - dofile(pipeworks.modpath.."/crafts.lua") dofile(pipeworks.modpath.."/tube_registration.lua") dofile(pipeworks.modpath.."/routing_tubes.lua") @@ -142,6 +125,7 @@ dofile(pipeworks.modpath.."/filter-injector.lua") dofile(pipeworks.modpath.."/trashcan.lua") dofile(pipeworks.modpath.."/wielder.lua") +if pipeworks.enable_pipes then dofile(pipeworks.modpath.."/pipes.lua") end if pipeworks.enable_teleport_tube then dofile(pipeworks.modpath.."/teleport_tube.lua") end if pipeworks.enable_pipe_devices then dofile(pipeworks.modpath.."/devices.lua") end if pipeworks.enable_redefines then dofile(pipeworks.modpath.."/compat.lua") end diff --git a/mods/pipeworks/pipes.lua b/mods/pipeworks/pipes.lua index 79d6d58b..2056fdfa 100644 --- a/mods/pipeworks/pipes.lua +++ b/mods/pipeworks/pipes.lua @@ -2,6 +2,9 @@ local REGISTER_COMPATIBILITY = true +local pipes_empty_nodenames = {} +local pipes_full_nodenames = {} + local vti = {4, 3, 2, 1, 6, 5} local cconnects = {{}, {1}, {1, 2}, {1, 3}, {1, 3, 5}, {1, 2, 3}, {1, 2, 3, 5}, {1, 2, 3, 4}, {1, 2, 3, 4, 5}, {1, 2, 3, 4, 5, 6}} for index, connects in ipairs(cconnects) do @@ -110,10 +113,12 @@ for index, connects in ipairs(cconnects) do end }) - table.insert(pipeworks.pipe_nodenames, "pipeworks:pipe_"..index.."_empty") - table.insert(pipeworks.pipe_nodenames, "pipeworks:pipe_"..index.."_loaded") + table.insert(pipes_empty_nodenames, "pipeworks:pipe_"..index.."_empty") + table.insert(pipes_full_nodenames, "pipeworks:pipe_"..index.."_loaded") end + + if REGISTER_COMPATIBILITY then local cempty = "pipeworks:pipe_compatibility_empty" local cloaded = "pipeworks:pipe_compatibility_loaded" @@ -170,3 +175,48 @@ if REGISTER_COMPATIBILITY then }) end +table.insert(pipes_empty_nodenames,"pipeworks:valve_on_empty") +table.insert(pipes_empty_nodenames,"pipeworks:valve_off_empty") +table.insert(pipes_empty_nodenames,"pipeworks:entry_panel_empty") +table.insert(pipes_empty_nodenames,"pipeworks:flow_sensor_empty") + +table.insert(pipes_full_nodenames,"pipeworks:valve_on_loaded") +table.insert(pipes_full_nodenames,"pipeworks:entry_panel_loaded") +table.insert(pipes_full_nodenames,"pipeworks:flow_sensor_loaded") + +minetest.register_abm({ + nodenames = pipes_empty_nodenames, + interval = 1, + chance = 1, + action = function(pos, node, active_object_count, active_object_count_wider) + pipeworks.check_for_inflows(pos,node) + end +}) + +minetest.register_abm({ + nodenames = pipes_full_nodenames, + interval = 1, + chance = 1, + action = function(pos, node, active_object_count, active_object_count_wider) + pipeworks.check_sources(pos,node) + end +}) + +minetest.register_abm({ + nodenames = {"pipeworks:spigot","pipeworks:spigot_pouring"}, + interval = 1, + chance = 1, + action = function(pos, node, active_object_count, active_object_count_wider) + pipeworks.spigot_check(pos,node) + end +}) + +minetest.register_abm({ + nodenames = {"pipeworks:fountainhead","pipeworks:fountainhead_pouring"}, + interval = 1, + chance = 1, + action = function(pos, node, active_object_count, active_object_count_wider) + pipeworks.fountainhead_check(pos,node) + end +}) + diff --git a/mods/pipeworks/vacuum_tubes.lua b/mods/pipeworks/vacuum_tubes.lua index f76585d5..f987589a 100644 --- a/mods/pipeworks/vacuum_tubes.lua +++ b/mods/pipeworks/vacuum_tubes.lua @@ -107,9 +107,9 @@ local function vacuum(pos, radius) end minetest.register_abm({nodenames = {"group:vacuum_tube"}, - label = "Vacuum tubes", interval = 1, chance = 1, + label = "Vacuum tubes", action = function(pos, node, active_object_count, active_object_count_wider) if node.name == "pipeworks:sand_tube" then vacuum(pos, 2)