builtin/game/falling.lua

   1 -- Minetest: builtin/item.lua
   2
   3 --
   4 -- Falling stuff
   5 --
   6
   7 core.register_entity(":__builtin:falling_node", {
   8         initial_properties = {
   9                 visual = "wielditem",
  10                 visual_size = {x = 0.667, y = 0.667},
  11                 textures = {},
  12                 physical = true,
  13                 is_visible = false,
  14                 collide_with_objects = false,
  15                 collisionbox = {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
  16         },
  17
  18         node = {},
  19
  20         set_node = function(self, node)
  21                 self.node = node
  22                 self.object:set_properties({
  23                         is_visible = true,
  24                         textures = {node.name},
  25                 })
  26         end,
  27
  28         get_staticdata = function(self)
  29                 return core.serialize(self.node)
  30         end,
  31
  32         on_activate = function(self, staticdata)
  33                 -- Set gravity
  34                 self.object:setacceleration({x = 0, y = -10, z = 0})
  35                 self.object:set_armor_groups({immortal = 1})
  36
  37                 local node = core.deserialize(staticdata)
  38                 if node then
  39                         self:set_node(node)
  40                 elseif staticdata ~= "" then
  41                         self:set_node({name = staticdata})
  42                 end
  43         end,
  44
  45         on_step = function(self, dtime)
  46                 -- Turn to actual sand when collides to ground or just move
  47                 local pos = self.object:getpos()
  48                 local bcp = {x = pos.x, y = pos.y - 0.7, z = pos.z} -- Position of bottom center point
  49                 local bcn = core.get_node(bcp)
  50                 local bcd = core.registered_nodes[bcn.name]
  51                 -- Note: walkable is in the node definition, not in item groups
  52                 if not bcd or
  53                                 (bcd.walkable or
  54                                 (core.get_item_group(self.node.name, "float") ~= 0 and
  55                                 bcd.liquidtype ~= "none")) then
  56                         if bcd and bcd.leveled and
  57                                         bcn.name == self.node.name then
  58                                 local addlevel = self.node.level
  59                                 if not addlevel or addlevel <= 0 then
  60                                         addlevel = bcd.leveled
  61                                 end
  62                                 if core.add_node_level(bcp, addlevel) == 0 then
  63                                         self.object:remove()
  64                                         return
  65                                 end
  66                         elseif bcd and bcd.buildable_to and
  67                                         (core.get_item_group(self.node.name, "float") == 0 or
  68                                         bcd.liquidtype == "none") then
  69                                 core.remove_node(bcp)
  70                                 return
  71                         end
  72                         local np = {x = bcp.x, y = bcp.y + 1, z = bcp.z}
  73                         -- Check what's here
  74                         local n2 = core.get_node(np)
  75                         -- If it's not air or liquid, remove node and replace it with
  76                         -- it's drops
  77                         if n2.name ~= "air" and (not core.registered_nodes[n2.name] or
  78                                         core.registered_nodes[n2.name].liquidtype == "none") then
  79                                 core.remove_node(np)
  80                                 if core.registered_nodes[n2.name].buildable_to == false then
  81                                         -- Add dropped items
  82                                         local drops = core.get_node_drops(n2.name, "")
  83                                         for _, dropped_item in ipairs(drops) do
  84                                                 core.add_item(np, dropped_item)
  85                                         end
  86                                 end
  87                                 -- Run script hook
  88                                 for _, callback in ipairs(core.registered_on_dignodes) do
  89                                         callback(np, n2)
  90                                 end
  91                         end
  92                         -- Create node and remove entity
  93                         core.add_node(np, self.node)
  94                         self.object:remove()
  95                         nodeupdate(np)
  96                         return
  97                 end
  98                 local vel = self.object:getvelocity()
  99                 if vector.equals(vel, {x = 0, y = 0, z = 0}) then
 100                         local npos = self.object:getpos()
 101                         self.object:setpos(vector.round(npos))
 102                 end
 103         end
 104 })
 105
 106 function spawn_falling_node(p, node)
 107         local obj = core.add_entity(p, "__builtin:falling_node")
 108         obj:get_luaentity():set_node(node)
 109 end
 110
 111 function drop_attached_node(p)
 112         local nn = core.get_node(p).name
 113         core.remove_node(p)
 114         for _, item in ipairs(core.get_node_drops(nn, "")) do
 115                 local pos = {
 116                         x = p.x + math.random()/2 - 0.25,
 117                         y = p.y + math.random()/2 - 0.25,
 118                         z = p.z + math.random()/2 - 0.25,
 119                 }
 120                 core.add_item(pos, item)
 121         end
 122 end
 123
 124 function check_attached_node(p, n)
 125         local def = core.registered_nodes[n.name]
 126         local d = {x = 0, y = 0, z = 0}
 127         if def.paramtype2 == "wallmounted" then
 128                 d = core.wallmounted_to_dir(n.param2)
 129         else
 130                 d.y = -1
 131         end
 132         local p2 = vector.add(p, d)
 133         local nn = core.get_node(p2).name
 134         local def2 = core.registered_nodes[nn]
 135         if def2 and not def2.walkable then
 136                 return false
 137         end
 138         return true
 139 end
 140
 141 --
 142 -- Some common functions
 143 --
 144
 145 function nodeupdate_single(p, delay)
 146         local n = core.get_node(p)
 147         if core.get_item_group(n.name, "falling_node") ~= 0 then
 148                 local p_bottom = {x = p.x, y = p.y - 1, z = p.z}
 149                 local n_bottom = core.get_node(p_bottom)
 150                 -- Note: walkable is in the node definition, not in item groups
 151                 if core.registered_nodes[n_bottom.name] and
 152                                 (core.get_item_group(n.name, "float") == 0 or
 153                                         core.registered_nodes[n_bottom.name].liquidtype == "none") and
 154                                 (n.name ~= n_bottom.name or (core.registered_nodes[n_bottom.name].leveled and
 155                                         core.get_node_level(p_bottom) < core.get_node_max_level(p_bottom))) and
 156                                 (not core.registered_nodes[n_bottom.name].walkable or
 157                                         core.registered_nodes[n_bottom.name].buildable_to) then
 158                         if delay then
 159                                 core.after(0.1, nodeupdate_single, p, false)
 160                         else
 161                                 n.level = core.get_node_level(p)
 162                                 core.remove_node(p)
 163                                 spawn_falling_node(p, n)
 164                                 nodeupdate(p)
 165                         end
 166                 end
 167         end
 168
 169         if core.get_item_group(n.name, "attached_node") ~= 0 then
 170                 if not check_attached_node(p, n) then
 171                         drop_attached_node(p)
 172                         nodeupdate(p)
 173                 end
 174         end
 175 end
 176
 177 function nodeupdate(p, delay)
 178         -- Round p to prevent falling entities to get stuck
 179         p = vector.round(p)
 180
 181         for x = -1, 1 do
 182         for y = -1, 1 do
 183         for z = -1, 1 do
 184                 local d = vector.new(x, y, z)
 185                 nodeupdate_single(vector.add(p, d), delay or not (x == 0 and y == 0 and z == 0))
 186         end
 187         end
 188         end
 189 end
 190
 191 --
 192 -- Global callbacks
 193 --
 194
 195 function on_placenode(p, node)
 196         nodeupdate(p)
 197 end
 198 core.register_on_placenode(on_placenode)
 199
 200 function on_dignode(p, node)
 201         nodeupdate(p)
 202 end
 203 core.register_on_dignode(on_dignode)