rewrote autoplacement code to make it more aware of filters,

autocrafter, nodebreaker, deployer, and made sure each item will only
initiate a connection to those sides which can accept such.  Fixed
various autorouting bugs as I ran across them.  Autorouting for various
devices is now:

filters: left and right sides only
nodebreaker, deployer:  back only
autocrafter:  all six sides
chests:  top, bottom, left, right, back (not front)
furnace: bottom, left, right, back (not the top or front)

diff --git a/autocrafter.lua b/autocrafter.lua
index a28faecc10f386c1804eca43a68ac69760ecbc49..1266a20ce1a21cb7ac2f71c4e26c548b8c47a904 100644 (file)
--- a/autocrafter.lua
+++ b/autocrafter.lua
@@ -71,11 +71,15 @@ minetest.register_node("pipeworks:autocrafter",{
                local meta = minetest.env:get_meta(pos);
                local inv = meta:get_inventory()
                return (inv:is_empty("src") and inv:is_empty("recipe") and inv:is_empty("dst"))
-       end})
+       end,
+       after_place_node = tube_scanforobjects,
+       after_dig_node = tube_scanforobjects,
+})
 
 minetest.register_abm({nodenames={"pipeworks:autocrafter"},interval=1,chance=1,
                        action=function(pos,node)
                                local meta=minetest.env:get_meta(pos)
                                local inv=meta:get_inventory()
                                autocraft(inv)
-                       end})
+                       end
+})

diff --git a/autoplace.lua b/autoplace.lua
index c58a58b9ec82951d6bd4d1cab47d5ab93666f8d4..1f75f07850355b72bdd15608f523c2593a474498 100644 (file)
--- a/autoplace.lua
+++ b/autoplace.lua
@@ -32,6 +32,8 @@ end
 -- autorouting for pneumatic tubes
 
 function tube_scanforobjects(pos)
+       if pos == nil then return end
+       print("tubes_scanforobjects called at pos "..dump(pos))
        tube_autoroute({ x=pos.x-1, y=pos.y  , z=pos.z   })
        tube_autoroute({ x=pos.x+1, y=pos.y  , z=pos.z   })
        tube_autoroute({ x=pos.x  , y=pos.y-1, z=pos.z   })
@@ -53,37 +55,187 @@ function is_tube(nodename)
 end
 
 function tube_autoroute(pos)
-       nctr = minetest.env:get_node(pos)
-       --print ("minetest.get_item_group("..nctr.name..',"tubedevice") == '..minetest.get_item_group(nctr.name, "tubedevice"))
-       if (is_tube(nctr.name) == nil)
-               and minetest.get_item_group(nctr.name, "tubedevice") ~= 1 then return end
+       local pxm=0
+       local pxp=0
+       local pym=0
+       local pyp=0
+       local pzm=0
+       local pzp=0
+
+       local nxm = minetest.env:get_node({ x=pos.x-1, y=pos.y  , z=pos.z   })
+       local nxp = minetest.env:get_node({ x=pos.x+1, y=pos.y  , z=pos.z   })
+       local nym = minetest.env:get_node({ x=pos.x  , y=pos.y-1, z=pos.z   })
+       local nyp = minetest.env:get_node({ x=pos.x  , y=pos.y+1, z=pos.z   })
+       local nzm = minetest.env:get_node({ x=pos.x  , y=pos.y  , z=pos.z-1 })
+       local nzp = minetest.env:get_node({ x=pos.x  , y=pos.y  , z=pos.z+1 })
+
+       local nctr = minetest.env:get_node(pos)
+
+-- handle the tubes themselves
+
+       if is_tube(nxm.name) then pxm=1 end
+       if is_tube(nxp.name) then pxp=1 end
+       if is_tube(nym.name) then pym=1 end
+       if is_tube(nyp.name) then pyp=1 end
+       if is_tube(nzm.name) then pzm=1 end
+       if is_tube(nzp.name) then pzp=1 end
+
+-- handle regular filters
+
+       if string.find(nxm.name, "pipeworks:filter") ~= nil
+         and (nxm.param2 == 0 or nxm.param2 == 2) then
+               pxm=1 end
+       if string.find(nxp.name, "pipeworks:filter") ~= nil
+         and (nxp.param2 == 0 or nxp.param2 == 2) then
+               pxp=1 end
+       if string.find(nzm.name, "pipeworks:filter") ~= nil
+         and (nzm.param2 == 1 or nzm.param2 == 3) then
+               pzm=1 end
+       if string.find(nzp.name, "pipeworks:filter") ~= nil
+         and (nzp.param2 == 1 or nzp.param2 == 3) then
+               pzp=1 end
 
-       pxm=0
-       pxp=0
-       pym=0
-       pyp=0
-       pzm=0
-       pzp=0
+-- handle mese filters
 
-       nxm = minetest.env:get_node({ x=pos.x-1, y=pos.y  , z=pos.z   })
-       nxp = minetest.env:get_node({ x=pos.x+1, y=pos.y  , z=pos.z   })
-       nym = minetest.env:get_node({ x=pos.x  , y=pos.y-1, z=pos.z   })
-       nyp = minetest.env:get_node({ x=pos.x  , y=pos.y+1, z=pos.z   })
-       nzm = minetest.env:get_node({ x=pos.x  , y=pos.y  , z=pos.z-1 })
-       nzp = minetest.env:get_node({ x=pos.x  , y=pos.y  , z=pos.z+1 })
+       if string.find(nxm.name, "pipeworks:mese_filter") ~= nil
+         and (nxm.param2 == 0 or nxm.param2 == 2) then
+               pxm=1 end
+       if string.find(nxp.name, "pipeworks:mese_filter") ~= nil
+         and (nxp.param2 == 0 or nxp.param2 == 2) then
+               pxp=1 end
+
+       if string.find(nzm.name, "pipeworks:mese_filter") ~= nil
+         and (nzm.param2 == 1 or nzm.param2 == 3) then
+               pzm=1 end
+       if string.find(nzp.name, "pipeworks:mese_filter") ~= nil
+         and (nzp.param2 == 1 or nzp.param2 == 3) then
+               pzp=1 end
+
+-- handle deployers
+
+       if string.find(nxm.name, "pipeworks:deployer_") ~= nil
+         and nxm.param2 == 1 then
+               pxm=1 end
+       if string.find(nxp.name, "pipeworks:deployer_") ~= nil
+         and nxp.param2 == 3 then
+               pxp=1 end
+       if string.find(nzm.name, "pipeworks:deployer_") ~= nil
+         and nzm.param2 == 0 then
+               pzm=1 end
+       if string.find(nzp.name, "pipeworks:deployer_") ~= nil
+         and nzp.param2 == 2 then
+               pzp=1 end
+
+--node breakers
+
+       if string.find(nxm.name, "pipeworks:nodebreaker_") ~= nil
+         and nxm.param2 == 1 then
+               pxm=1 end
+       if string.find(nxp.name, "pipeworks:nodebreaker_") ~= nil
+         and nxp.param2 == 3 then
+               pxp=1 end
+       if string.find(nzm.name, "pipeworks:nodebreaker_") ~= nil
+         and nzm.param2 == 0 then
+               pzm=1 end
+       if string.find(nzp.name, "pipeworks:nodebreaker_") ~= nil
+         and nzp.param2 == 2 then
+               pzp=1 end
+
+-- autocrafter
+
+       if string.find(nxm.name, "pipeworks:autocrafter") ~= nil then pxm = 1 end
+       if string.find(nxp.name, "pipeworks:autocrafter") ~= nil then pxp = 1 end
+       if string.find(nym.name, "pipeworks:autocrafter") ~= nil then pym = 1 end
+       if string.find(nyp.name, "pipeworks:autocrafter") ~= nil then pyp = 1 end
+       if string.find(nzm.name, "pipeworks:autocrafter") ~= nil then pzm = 1 end
+       if string.find(nzp.name, "pipeworks:autocrafter") ~= nil then pzp = 1 end
+
+--chests
+
+       -- check for left/right connects
+
+       if string.find(nxm.name, "default:chest") ~= nil
+         and (nxm.param2 == 0 or nxm.param2 == 2) then
+               pxm=1 end
+       if string.find(nxp.name, "default:chest") ~= nil
+         and (nxp.param2 == 0 or nxp.param2 == 2) then
+               pxp=1 end
+
+       if string.find(nzm.name, "default:chest") ~= nil
+         and (nzm.param2 == 1 or nzm.param2 == 3) then
+               pzm=1 end
+       if string.find(nzp.name, "default:chest") ~= nil
+         and (nzp.param2 == 1 or nzp.param2 == 3) then
+               pzp=1 end
+
+       -- check for backside connects
+
+       if string.find(nxm.name, "default:chest") ~= nil
+         and nxm.param2 == 1 then
+               pxm = 1 end
+
+       if string.find(nxp.name, "default:chest") ~= nil
+         and nxp.param2 == 3 then
+               pxp = 1 end
+
+       if string.find(nzm.name, "default:chest") ~= nil
+         and nzm.param2 == 0 then
+               pzm = 1 end
+
+       if string.find(nzp.name, "default:chest") ~= nil
+         and nzp.param2 == 2 then
+               pzp = 1 end
+
+       -- check for top/bottom connections
+
+       if string.find(nym.name, "default:chest") ~= nil then pym = 1 end
+       if string.find(nyp.name, "default:chest") ~= nil then pyp = 1 end
+
+       -- does not scan for the front side of the node.
+
+--chests
+
+       -- check for left/right connects
+
+       if string.find(nxm.name, "default:furnace") ~= nil
+         and (nxm.param2 == 0 or nxm.param2 == 2) then
+               pxm=1 end
+       if string.find(nxp.name, "default:furnace") ~= nil
+         and (nxp.param2 == 0 or nxp.param2 == 2) then
+               pxp=1 end
+
+       if string.find(nzm.name, "default:furnace") ~= nil
+         and (nzm.param2 == 1 or nzm.param2 == 3) then
+               pzm=1 end
+       if string.find(nzp.name, "default:furnace") ~= nil
+         and (nzp.param2 == 1 or nzp.param2 == 3) then
+               pzp=1 end
+
+       -- check for backside connects
+
+       if string.find(nxm.name, "default:furnace") ~= nil
+         and nxm.param2 == 1 then
+               pxm = 1 end
+
+       if string.find(nxp.name, "default:furnace") ~= nil
+         and nxp.param2 == 3 then
+               pxp = 1 end
+
+       if string.find(nzm.name, "default:furnace") ~= nil
+         and nzm.param2 == 0 then
+               pzm = 1 end
+
+       if string.find(nzp.name, "default:furnace") ~= nil
+         and nzp.param2 == 2 then
+               pzp = 1 end
+
+       -- check for bottom connection
+
+       if string.find(nyp.name, "default:furnace") ~= nil then pyp = 1 end
+
+       -- does not scan for the front or top side of the node.
 
-       if is_tube(nxm.name) 
-               or minetest.get_item_group(nxm.name, "tubedevice") == 1 then pxm=1 end
-       if is_tube(nxp.name) 
-               or minetest.get_item_group(nxp.name, "tubedevice") == 1 then pxp=1 end
-       if is_tube(nym.name) 
-               or minetest.get_item_group(nym.name, "tubedevice") == 1 then pym=1 end
-       if is_tube(nyp.name) 
-               or minetest.get_item_group(nyp.name, "tubedevice") == 1 then pyp=1 end
-       if is_tube(nzm.name) 
-               or minetest.get_item_group(nzm.name, "tubedevice") == 1 then pzm=1 end
-       if is_tube(nzp.name) 
-               or minetest.get_item_group(nzp.name, "tubedevice") == 1 then pzp=1 end
+-- Apply the final routing decisions to the existing tube (if any)
 
        nsurround = pxm..pxp..pym..pyp..pzm..pzp
        if is_tube(nctr.name) then

diff --git a/compat.lua b/compat.lua
index 6f555d061374d65d5d13057932f56262e4efc63b..55d207ac5451a5d569f88e682ff89a9342df2615 100644 (file)
--- a/compat.lua
+++ b/compat.lua
@@ -10,9 +10,9 @@ function clone_node(name)
 end
 
 furnace=clone_node("default:furnace")
-furnace.groups.tubedevice=1
-furnace.groups.tubedevice_receiver=1
-furnace.tube={insert_object=function(pos,node,stack,direction)
+       furnace.groups.tubedevice=1
+       furnace.groups.tubedevice_receiver=1
+       furnace.tube={insert_object = function(pos,node,stack,direction)
                        local meta=minetest.env:get_meta(pos)
                        local inv=meta:get_inventory()
                        if direction.y==1 then
@@ -21,73 +21,79 @@ furnace.tube={insert_object=function(pos,node,stack,direction)
                                return inv:add_item("src",stack)
                        end
                end,
-               can_insert=function(pos,node,stack,direction)
-                       local meta=minetest.env:get_meta(pos)
-                       local inv=meta:get_inventory()
-                       if direction.y==1 then
-                               return inv:room_for_item("fuel",stack)
-                       elseif direction.y==-1 then
-                               return inv:room_for_item("src",stack)
-                       else
-                               return 0
-                       end
-               end,
-               input_inventory="dst"}
-furnace.after_place_node= function(pos)
-                               tube_scanforobjects(pos)
-                       end
-furnace.after_dig_node = function(pos)
-                               tube_scanforobjects(pos)
-                       end
-minetest.register_node(":default:furnace",furnace)
+       can_insert=function(pos,node,stack,direction)
+               local meta=minetest.env:get_meta(pos)
+               local inv=meta:get_inventory()
+               if direction.y==1 then
+                       return inv:room_for_item("fuel",stack)
+               elseif direction.y==-1 then
+                       return inv:room_for_item("src",stack)
+               else
+                       return 0
+       end
+       end,
+       input_inventory="dst"}
+       furnace.after_place_node= function(pos)
+               tube_scanforobjects(pos)
+       end
+       furnace.after_dig_node = function(pos)
+               tube_scanforobjects(pos)
+       end
 
+minetest.register_node(":default:furnace",furnace)
 
 furnace=clone_node("default:furnace_active")
-furnace.groups.tubedevice=1
-furnace.groups.tubedevice_receiver=1
-furnace.tube={insert_object=function(pos,node,stack,direction)
-                       local meta=minetest.env:get_meta(pos)
-                       local inv=meta:get_inventory()
-                       if direction.y==1 then
-                               return inv:add_item("fuel",stack)
-                       else
-                               return inv:add_item("src",stack)
-                       end
-               end,
-               can_insert=function(pos,node,stack,direction)
-                       local meta=minetest.env:get_meta(pos)
-                       local inv=meta:get_inventory()
-                       if direction.y==1 then
-                               return inv:room_for_item("fuel",stack)
-                       elseif direction.y==-1 then
-                               return inv:room_for_item("src",stack)
-                       else
-                               return 0
-                       end
-               end,
-               input_inventory="dst"}
-furnace.after_place_node= function(pos)
-                               tube_scanforobjects(pos)
-                       end
-furnace.after_dig_node = function(pos)
-                               tube_scanforobjects(pos)
-                       end
-minetest.register_node(":default:furnace_active",furnace)
+       furnace.groups.tubedevice=1
+       furnace.groups.tubedevice_receiver=1
+       furnace.tube={insert_object=function(pos,node,stack,direction)
+               local meta=minetest.env:get_meta(pos)
+               local inv=meta:get_inventory()
+               if direction.y==1 then
+                       return inv:add_item("fuel",stack)
+               else
+                       return inv:add_item("src",stack)
+               end
+       end,
+       can_insert=function(pos,node,stack,direction)
+               local meta=minetest.env:get_meta(pos)
+               local inv=meta:get_inventory()
+               if direction.y==1 then
+                       return inv:room_for_item("fuel",stack)
+               elseif direction.y==-1 then
+                       return inv:room_for_item("src",stack)
+               else
+                       return 0
+               end
+       end,
+       input_inventory="dst"}
+       furnace.after_place_node= function(pos)
+               tube_scanforobjects(pos)
+       end
+       furnace.after_dig_node = function(pos)
+               tube_scanforobjects(pos)
+       end
+       minetest.register_node(":default:furnace_active",furnace)
+
 
 chest=clone_node("default:chest")
-chest.groups.tubedevice=1
-chest.groups.tubedevice_receiver=1
-chest.tube={insert_object=function(pos,node,stack,direction)
-                       local meta=minetest.env:get_meta(pos)
-                       local inv=meta:get_inventory()
-                       return inv:add_item("main",stack)
-               end,
-               can_insert=function(pos,node,stack,direction)
-                       local meta=minetest.env:get_meta(pos)
-                       local inv=meta:get_inventory()
-                       return inv:room_for_item("main",stack)
-               end,
-               input_inventory="main"}
-chest.after_place_node = tube_scanforobjects(pos)
-chest.after_dig_node = tube_scanforobjects
+       chest.groups.tubedevice=1
+       chest.groups.tubedevice_receiver=1
+       chest.tube={insert_object = function(pos,node,stack,direction)
+               local meta=minetest.env:get_meta(pos)
+               local inv=meta:get_inventory()
+               return inv:add_item("main",stack)
+       end,
+       can_insert=function(pos,node,stack,direction)
+               local meta=minetest.env:get_meta(pos)
+               local inv=meta:get_inventory()
+               return inv:room_for_item("main",stack)
+       end,
+       input_inventory="main"}
+       chest.after_place_node = function(pos)
+               tube_scanforobjects(pos)
+       end
+       chest.after_dig_node = function(pos)
+               tube_scanforobjects(pos)
+       end
+
 minetest.register_node(":default:chest",chest)

diff --git a/item_transport.lua b/item_transport.lua
index d5cb7cdb596efbfa15bfc927f7a93b55b6f8558d..12a177c2cca460d73a4c8c4d1d6ca5aa859c01ed 100644 (file)
--- a/item_transport.lua
+++ b/item_transport.lua
@@ -33,6 +33,9 @@ minetest.register_node("pipeworks:filter", {
        after_place_node = function(pos)
                tube_scanforobjects(pos)
        end,
+       after_dig_node = function(pos)
+               tube_scanforobjects(pos)
+       end,
        mesecons={effector={action_on=function(pos,node)
                                        minetest.registered_nodes[node.name].on_punch(pos,node,nil)
                                end}},
@@ -125,6 +128,12 @@ minetest.register_node("pipeworks:mese_filter", {
                local inv = meta:get_inventory()
                return inv:is_empty("main")
        end,
+       after_place_node = function(pos)
+               tube_scanforobjects(pos)
+       end,
+       after_dig_node = function(pos)
+               tube_scanforobjects(pos)
+       end,
        mesecons={effector={action_on=function(pos,node)
                                        minetest.registered_nodes[node.name].on_punch(pos,node,nil)
                                end}},

diff --git a/node_breaker.lua b/node_breaker.lua
index cda2692f662e44a3ecc4c55c61cfbcd58d079370..2ebcac6c795ba5f8cdc74e18eb9c060c33afa0fb 100644 (file)
--- a/node_breaker.lua
+++ b/node_breaker.lua
@@ -108,4 +108,4 @@ minetest.register_node("pipeworks:nodebreaker_on", {
        sounds = default.node_sound_stone_defaults(),
        after_place_node = tube_scanforobjects,
        after_dig_node = tube_scanforobjects,
-})
\ No newline at end of file
+})