Assume a selection box for fences

[minetest.git] / builtin / falling.lua

diff --git a/builtin/falling.lua b/builtin/falling.lua
index 5ee693298519bc01a8f4b842446a98bebcfa1789..c8f3bc556a4d7903a083d1eef4e3f516d4d18865 100644 (file)
--- a/builtin/falling.lua
+++ b/builtin/falling.lua
@@ -7,17 +7,18 @@
 minetest.register_entity("__builtin:falling_node", {
        initial_properties = {
                physical = true,
+               collide_with_objects = false,
                collisionbox = {-0.5,-0.5,-0.5, 0.5,0.5,0.5},
                visual = "wielditem",
                textures = {},
                visual_size = {x=0.667, y=0.667},
        },
 
-       nodename = "",
+       node = {},
 
-       set_node = function(self, nodename)
-               self.nodename = nodename
-               local stack = ItemStack(nodename)
+       set_node = function(self, node)
+               self.node = node
+               local stack = ItemStack(node.name)
                local itemtable = stack:to_table()
                local itemname = nil
                if itemtable then
@@ -31,20 +32,19 @@ minetest.register_entity("__builtin:falling_node", {
                end
                prop = {
                        is_visible = true,
-                       textures = {nodename},
+                       textures = {node.name},
                }
                self.object:set_properties(prop)
        end,
 
        get_staticdata = function(self)
-               return self.nodename
+               return self.node.name
        end,
 
        on_activate = function(self, staticdata)
-               self.nodename = staticdata
                self.object:set_armor_groups({immortal=1})
                --self.object:setacceleration({x=0, y=-10, z=0})
-               self:set_node(self.nodename)
+               self:set_node({name=staticdata})
        end,
 
        on_step = function(self, dtime)
@@ -54,10 +54,25 @@ minetest.register_entity("__builtin:falling_node", {
                local pos = self.object:getpos()
                local bcp = {x=pos.x, y=pos.y-0.7, z=pos.z} -- Position of bottom center point
                local bcn = minetest.get_node(bcp)
+               local bcd = minetest.registered_nodes[bcn.name]
                -- Note: walkable is in the node definition, not in item groups
-               if minetest.registered_nodes[bcn.name] and
-                               minetest.registered_nodes[bcn.name].walkable then
-                       if minetest.registered_nodes[bcn.name].buildable_to then
+               if not bcd or
+                               (bcd.walkable or
+                               (minetest.get_node_group(self.node.name, "float") ~= 0 and
+                               bcd.liquidtype ~= "none")) then
+                       if bcd and bcd.leveled and
+                                       bcn.name == self.node.name then
+                               local addlevel = self.node.level
+                               if addlevel == nil or addlevel <= 0 then
+                                       addlevel = bcd.leveled
+                               end
+                               if minetest.add_node_level(bcp, addlevel) == 0 then
+                                       self.object:remove()
+                                       return
+                               end
+                       elseif bcd and bcd.buildable_to and
+                                       (minetest.get_node_group(self.node.name, "float") == 0 or
+                                       bcd.liquidtype == "none") then
                                minetest.remove_node(bcp)
                                return
                        end
@@ -82,7 +97,7 @@ minetest.register_entity("__builtin:falling_node", {
                                end
                        end
                        -- Create node and remove entity
-                       minetest.add_node(np, {name=self.nodename})
+                       minetest.add_node(np, self.node)
                        self.object:remove()
                        nodeupdate(np)
                else
@@ -91,9 +106,9 @@ minetest.register_entity("__builtin:falling_node", {
        end
 })
 
-function spawn_falling_node(p, nodename)
+function spawn_falling_node(p, node)
        obj = minetest.add_entity(p, "__builtin:falling_node")
-       obj:get_luaentity():set_node(nodename)
+       obj:get_luaentity():set_node(node)
 end
 
 function drop_attached_node(p)
@@ -149,13 +164,16 @@ function nodeupdate_single(p, delay)
                n_bottom = minetest.get_node(p_bottom)
                -- Note: walkable is in the node definition, not in item groups
                if minetest.registered_nodes[n_bottom.name] and
+                               (minetest.get_node_group(n.name, "float") == 0 or minetest.registered_nodes[n_bottom.name].liquidtype == "none") and
+                               (n.name ~= n_bottom.name or (minetest.registered_nodes[n_bottom.name].leveled and minetest.env:get_node_level(p_bottom) < minetest.env:get_node_max_level(p_bottom))) and
                                (not minetest.registered_nodes[n_bottom.name].walkable or 
                                        minetest.registered_nodes[n_bottom.name].buildable_to) then
                        if delay then
                                minetest.after(0.1, nodeupdate_single, {x=p.x, y=p.y, z=p.z}, false)
                        else
+                               n.level = minetest.env:get_node_level(p)
                                minetest.remove_node(p)
-                               spawn_falling_node(p, n.name)
+                               spawn_falling_node(p, n)
                                nodeupdate(p)
                        end
                end
@@ -169,7 +187,7 @@ function nodeupdate_single(p, delay)
        end
 end
 
-function nodeupdate(p)
+function nodeupdate(p, delay)
        -- Round p to prevent falling entities to get stuck
        p.x = math.floor(p.x+0.5)
        p.y = math.floor(p.y+0.5)
@@ -178,7 +196,7 @@ function nodeupdate(p)
        for x = -1,1 do
        for y = -1,1 do
        for z = -1,1 do
-               nodeupdate_single({x=p.x+x, y=p.y+y, z=p.z+z}, not (x==0 and y==0 and z==0))
+               nodeupdate_single({x=p.x+x, y=p.y+y, z=p.z+z}, delay or not (x==0 and y==0 and z==0))
        end
        end
        end