minetest.register_entity(":__builtin:item", {
        {
        initial_properties = {
                {
                hp_max = 1,
                1,
                physical = true,
true,
                collisionbox = {-0.17,-0.17,-0.17, 0.17,0.17,0.17},
                17},
                visual = "sprite",
"sprite",
                visual_size = {x=0.5, y=0.5},
                5},
                textures = {""},
                {""},
                spritediv = {x=1, y=1},
                y=1},
                initial_sprite_basepos = {x=0, y=0},
                y=0},
                is_visible = false,
                false,
                timer = 0,
        },

        0,
        },

        itemstring = '',
        '',
        physical_state = true,

        true,

        set_item = function(self, itemstring)
itemstring)
                self.itemstring = itemstring
                itemstring
                local stack = ItemStack(itemstring)
                ItemStack(itemstring)
                local itemtable = stack:to_table()
                stack:to_table()
                local itemname = nil
                nil
                if itemtable then
then
                        itemname = stack:to_table().name
                end
                name
                end
                local item_texture = nil
                nil
                local item_type = ""
""
                if minetest.registered_items[itemname] then
then
                        item_texture = minetest.registered_items[itemname].inventory_image
inventory_image
                        item_type = minetest.registered_items[itemname].type
                end
                type
                end
                prop = {
                        {
                        is_visible = true,
                        true,
                        visual = "sprite",
"sprite",
                        textures = {"unknown_item.png"}
                }
                png"}
                }
                if item_texture and item_texture ~= "" then
then
                        prop.visual = "sprite"
"sprite"
                        prop.textures = {item_texture}
{item_texture}
                        prop.visual_size = {x=0.50, y=0.50}
                else
50}
                else
                        prop.visual = "wielditem"
"wielditem"
                        prop.textures = {itemname}
{itemname}
                        prop.visual_size = {x=0.20, y=0.20}
20}
                        prop.automatic_rotate = math.pi * 0.25
                end
25
                end
                self.object:set_properties(prop)
        end,

        object:set_properties(prop)
        end,

        get_staticdata = function(self)
function(self)
                --return self.itemstring
itemstring
                return minetest.serialize({
serialize({
                        itemstring = self.itemstring,
itemstring,
                        always_collect = self.always_collect,
always_collect,
                        timer = self.timer,
                })
        end,

        timer,
                })
        end,

        on_activate = function(self, staticdata, dtime_s)
dtime_s)
                if string.sub(staticdata, 1, string.len("return")) == "return" then
then
                        local data = minetest.deserialize(staticdata)
                        deserialize(staticdata)
                        if data and type(data) == "table" then
then
                                self.itemstring = data.itemstring
itemstring
                                self.always_collect = data.always_collect
always_collect
                                self.timer = data.timer
timer
                                if not self.timer then
then
                                        self.timer = 0
                                end
0
                                end
                                self.timer = self.timer+dtime_s
                        end
                else
timer+dtime_s
                        end
                else
                        self.itemstring = staticdata
                end
staticdata
                end
                self.object:set_armor_groups({immortal=1})
object:set_armor_groups({immortal=1})
                self.object:setvelocity({x=0, y=2, z=0})
z=0})
                self.object:setacceleration({x=0, y=-10, z=0})
z=0})
                self:set_item(self.itemstring)
        end,

        itemstring)
        end,

        on_step = function(self, dtime)
dtime)
                local time = tonumber(minetest.setting_get("remove_items"))
                setting_get("remove_items"))
                if not time then
                        then
                        time = 7200
                end
7200
                end
                if not self.timer then
then
                        self.timer = 0
                end
0
                end
                self.timer = self.timer + dtime
dtime
                if time ~= 0 and (self.timer > time) then
then
                        self.object:remove()
                end

object:remove()
                end

                local p = self.object:getpos()
object:getpos()
                local name = minetest.env:get_node(p).name

name

                p.y = p.y - 0.3
3
                local nn = minetest.env:get_node(p).name
                name
                -- If node is not registered or node is walkably solid
solid
                if not minetest.registered_nodes[nn] or minetest.registered_nodes[nn].walkable then
then
                        if self.physical_state then
then
                                self.object:setvelocity({x=0,y=0,z=0})
object:setvelocity({x=0,y=0,z=0})
                                self.object:setacceleration({x=0, y=0, z=0})
z=0})
                                self.physical_state = false
false
                                self.object:set_properties({
                                        object:set_properties({
                                        physical = false
                                })
                        end
                else
false
                                })
                        end
                else
                        if not self.physical_state then
then
                                self.object:setvelocity({x=0,y=0,z=0})
object:setvelocity({x=0,y=0,z=0})
                                self.object:setacceleration({x=0, y=-10, z=0})
z=0})
                                self.physical_state = true
true
                                self.object:set_properties({
                                        object:set_properties({
                                        physical = true
                                })
                        end
                end
        end,

        true
                                })
                        end
                end
        end,

        on_punch = function(self, hitter)
hitter)
                if self.itemstring ~= '' then
then
                        local left = hitter:get_inventory():add_item("main", self.itemstring)
                        itemstring)
                        if not left:is_empty() then
then
                                self.itemstring = left:to_string()
                                return
                        end
                end
left:to_string()
                                return
                        end
                end
                self.object:remove()
        end,
})

object:remove()
        end,
})

if minetest.setting_get("log_mods") then
then
        minetest.log("action", "entity_cleaner loaded")
end
loaded")
end