local function get_falling_depth(self) if not self._startpos then -- Fallback self._startpos = self.object:get_pos() end return self._startpos.y - vector.round(self.object:get_pos()).y end local function deal_falling_damage(self, dtime) if minetest.get_item_group(self.node.name, "falling_node_damage") == 0 then return end -- Cause damage to any entity it hits. -- Algorithm based on MC anvils. local pos = self.object:get_pos() if not self._startpos then -- Fallback self._startpos = pos end self._hit = self._hit or {} for _, obj in ipairs(minetest.get_objects_inside_radius(pos, 1)) do local entity = obj:get_luaentity() if entity and entity.name == "__builtin:item" then obj:remove() elseif mcl_util.get_hp(obj) > 0 and not self._hit[obj] then self._hit[obj] = true local way = self._startpos.y - pos.y local damage = (way - 1) * 2 damage = math.min(40, math.max(0, damage)) if damage >= 1 then -- Reduce damage if wearing a helmet local inv = mcl_util.get_inventory(obj) if inv then local helmet = inv:get_stack("armor", 2) if minetest.get_item_group(helmet:get_name(), "combat_armor") > 0 then damage = damage / 4 * 3 mcl_util.use_item_durability(helmet, 1) inv:set_stack("armor", 2, helmet) end end local dmg_type if minetest.get_item_group(self.node.name, "anvil") ~= 0 then dmg_type = "anvil" else dmg_type = "falling_node" end mcl_util.deal_damage(obj, damage, {type = dmg_type}) end end end end minetest.register_entity(":__builtin:falling_node", { initial_properties = { visual = "wielditem", visual_size = {x = 0.667, y = 0.667}, textures = {}, physical = true, is_visible = false, collide_with_objects = false, collisionbox = {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5}, }, node = {}, meta = {}, set_node = function(self, node, meta) local def = minetest.registered_nodes[node.name] -- Change falling node if definition tells us to if def and def._mcl_falling_node_alternative then node.name = def._mcl_falling_node_alternative end local glow self.node = node self.meta = meta or {} -- Set correct entity yaw if def and node.param2 ~= 0 then if (def.paramtype2 == "facedir" or def.paramtype2 == "colorfacedir") then self.object:set_yaw(minetest.dir_to_yaw(minetest.facedir_to_dir(node.param2))) elseif (def.paramtype2 == "wallmounted" or def.paramtype2 == "colorwallmounted") then self.object:set_yaw(minetest.dir_to_yaw(minetest.wallmounted_to_dir(node.param2))) end if def.light_source then glow = def.light_source end end self.object:set_properties({ is_visible = true, textures = {node.name}, glow = glow, }) end, get_staticdata = function(self) if not self then return end local meta = self.meta -- Workaround: Save inventory seperately from metadata. -- Because Minetest crashes when a node with inventory gets deactivated -- (GitHub issue #7020). -- FIXME: Remove the _inv workaround when it is no longer needed local inv if meta then inv = meta.inv meta.inventory = nil end local ds = { node = self.node, meta = self.meta, _inv = inv, _startpos = self._startpos, _hit_players = self._hit_players, } return minetest.serialize(ds) end, on_activate = function(self, staticdata) self.object:set_armor_groups({immortal = 1}) local ds = minetest.deserialize(staticdata) if ds then self._startpos = ds._startpos self._hit_players = ds._hit_players if ds.node then local meta = ds.meta meta.inventory = ds._inv self:set_node(ds.node, meta) else self:set_node(ds) end elseif staticdata ~= "" then self:set_node({name = staticdata}) end if not self._startpos then self._startpos = self.object:get_pos() end self._startpos = vector.round(self._startpos) end, on_step = function(self, dtime) -- Set gravity local acceleration = self.object:get_acceleration() if not vector.equals(acceleration, {x = 0, y = -10, z = 0}) then self.object:set_acceleration({x = 0, y = -10, z = 0}) end -- Turn to actual node when colliding with ground, or continue to move local pos = self.object:get_pos() -- Portal check local np = {x = pos.x, y = pos.y + 0.3, z = pos.z} local n2 = minetest.get_node(np) if n2.name == "mcl_portals:portal_end" then -- TODO: Teleport falling node. self.object:remove() return end -- Position of bottom center point local bcp = {x = pos.x, y = pos.y - 0.7, z = pos.z} -- Avoid bugs caused by an unloaded node below local bcn = minetest.get_node_or_nil(bcp) local bcd = bcn and minetest.registered_nodes[bcn.name] -- TODO: At this point, we did 2 get_nodes in 1 tick. -- Figure out how to improve that (if it is a problem). if bcn and (not bcd or bcd.walkable or (minetest.get_item_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 not addlevel or addlevel <= 0 then addlevel = bcd.leveled end if minetest.add_node_level(bcp, addlevel) == 0 then if minetest.registered_nodes[self.node.name]._mcl_after_falling then minetest.registered_nodes[self.node.name]._mcl_after_falling(bcp, get_falling_depth(self)) end deal_falling_damage(self, dtime) self.object:remove() return end elseif bcd and bcd.buildable_to and (minetest.get_item_group(self.node.name, "float") == 0 or bcd.liquidtype == "none") then minetest.remove_node(bcp) return end local nd = minetest.registered_nodes[n2.name] --if n2.name == "mcl_portals:portal_end" then -- TODO: Teleport falling node. if (nd and nd.buildable_to == true) or minetest.get_item_group(self.node.name, "crush_after_fall") ~= 0 then -- Replace destination node if it's buildable to minetest.remove_node(np) -- Run script hook for _, callback in pairs(minetest.registered_on_dignodes) do callback(np, n2) end local def = minetest.registered_nodes[self.node.name] if def then minetest.add_node(np, self.node) if def._mcl_after_falling then def._mcl_after_falling(np, get_falling_depth(self)) end if self.meta then local meta = minetest.get_meta(np) meta:from_table(self.meta) end if def.sounds and def.sounds.place and def.sounds.place.name then minetest.sound_play(def.sounds.place, {pos = np}, true) end end else -- Drop the *falling node* as an item if the destination node is NOT buildable to local drops = minetest.get_node_drops(self.node.name, "") for _, dropped_item in pairs(drops) do minetest.add_item(np, dropped_item) end end deal_falling_damage(self, dtime) self.object:remove() minetest.check_for_falling(np) return end local vel = self.object:get_velocity() -- Fix position if entity does not move if vector.equals(vel, {x = 0, y = 0, z = 0}) then local npos = vector.round(self.object:get_pos()) local npos2 = table.copy(npos) npos2.y = npos2.y - 2 local lownode = minetest.get_node(npos2) -- Special check required for fences and walls, because of their overhigh collision box. if minetest.get_item_group(lownode.name, "fence") == 1 or minetest.get_item_group(lownode.name, "wall") == 1 then -- Instantly stop the node if it is above a fence/wall. This is needed -- because the falling node collides early with a fence/wall node. -- Hacky, because the falling node will teleport a short distance, instead -- of smoothly fall on the fence post. local npos3 = table.copy(npos) npos3.y = npos3.y - 1 minetest.add_node(npos3, self.node) local def = minetest.registered_nodes[self.node.name] if def then if def._mcl_after_falling then def._mcl_after_falling(npos3, get_falling_depth(self)) end if def.sounds and def.sounds.place and def.sounds.place.name then minetest.sound_play(def.sounds.place, {pos = np}, true) end end deal_falling_damage(self, dtime) self.object:remove() minetest.check_for_falling(npos3) return else -- Normal position fix (expected case) self.object:set_pos(npos) end end deal_falling_damage(self, dtime) end })