-- mods/default/functions.lua

-- ===================================================================

local                          enable_leaf_decay =
    minetest.setting_getbool ("enable_leaf_decay")

-- ===================================================================
-- Lavacooling
--

default.cool_lava = function(pos, node)
    if node.name == "default:lava_source" then
        minetest.set_node(pos, {name = "default:obsidian"})
    else -- Lava flowing
        minetest.set_node(pos, {name = "default:stone"})
    end
    minetest.sound_play("default_cool_lava",
        {pos = pos, max_hear_distance = 16, gain = 0.25})
end

-- ===================================================================

minetest.register_abm ({
    nodenames = { "default:lava_source", "default:lava_flowing" } ,
    neighbors = { "group:water" } ,

    catch_up  = false ,
    chance    = 1     ,
    interval  = 1     ,

    action    = function (...)
        default.cool_lava (...)
    end ,
})

-- ===================================================================
-- optimized helper to put all items in an inventory into a drops list
--

function default.get_inventory_drops(pos, inventory, drops)
    local inv = minetest.get_meta(pos):get_inventory()
    local n = #drops
    for i = 1, inv:get_size(inventory) do
        local stack = inv:get_stack(inventory, i)
        if stack:get_count() > 0 then
            drops[n+1] = stack:to_table()
            n = n + 1
        end
    end
end

-- ===================================================================
-- Papyrus and cactus growing

-- wrapping the functions in abm action is necessary to make overriding them possible

function default.grow_cactus(pos, node)
    if node.param2 >= 4 then
        return
    end
    pos.y = pos.y - 1
    if minetest.get_item_group(minetest.get_node(pos).name, "sand") == 0 then
        return
    end
    pos.y = pos.y + 1
    local height = 0
    while node.name == "default:cactus" and height < 4 do
        height = height + 1
        pos.y = pos.y + 1
        node = minetest.get_node(pos)
    end
    if height == 4 or node.name ~= "air" then
        return
    end
    minetest.set_node(pos, {name = "default:cactus"})
    return true
end

-- ===================================================================

default.grow_papyrus = function (pos, node)
    pos.y = pos.y - 1

    local dirt_node = minetest.get_node (pos)
    local dirt_name = dirt_node.name
    local groups    = minetest.registered_nodes [dirt_name].groups

    if groups.soil == nil or groups.soil == 0 then
        return
    end

    if not minetest.find_node_near (pos, 3, {"group:water"}) then
        return
    end

    pos.y = pos.y + 1           -- Point to papyrus again
    local height = 0

    while node.name == "default:papyrus" and height < 4 do
        height = height + 1
        pos.y  = pos.y  + 1
        node   = minetest.get_node (pos)
    end

    if height == 4 or node.name ~= "air" then
        return
    end

    minetest.set_node (pos, { name = "default:papyrus" })
    return true
end

-- ===================================================================

minetest.register_abm ({
    nodenames = { "default:cactus" } ,
    neighbors = { "group:sand"     } ,

    catch_up  = false ,
    chance    = 83    ,
    interval  = 12    ,

    action    = function (...)
        default.grow_cactus (...)
    end
})

-- ===================================================================

minetest.register_abm ({
    nodenames = { "default:papyrus" } ,
    neighbors = { "group:soil"      } ,

    catch_up  = false ,
    chance    = 71    ,
    interval  = 14    ,

    action   = function (...)
        default.grow_papyrus (...)
    end
})

-- ===================================================================
-- dig upwards
--

function default.dig_up(pos, node, digger)
    if digger == nil then return end
    local np = {x = pos.x, y = pos.y + 1, z = pos.z}
    local nn = minetest.get_node(np)
    if nn.name == node.name then
        minetest.node_dig(np, nn, digger)
    end
end

-- ===================================================================
-- Fence registration helper
--

function default.register_fence(name, def)
    minetest.register_craft({
        output = name .. " 4",
        recipe = {
            { def.material, 'group:stick', def.material },
            { def.material, 'group:stick', def.material },
        }
    })

    local fence_texture = "default_fence_overlay.png^" .. def.texture ..
            "^default_fence_overlay.png^[makealpha:255,126,126"
    -- Allow almost everything to be overridden
    local default_fields = {
        paramtype = "light",
        drawtype = "nodebox",
        node_box = {
            type = "connected",
            fixed = {{-1/8, -1/2, -1/8, 1/8, 1/2, 1/8}},
            -- connect_top =
            -- connect_bottom =
            connect_front = {{-1/16,3/16,-1/2,1/16,5/16,-1/8},
                {-1/16,-5/16,-1/2,1/16,-3/16,-1/8}},
            connect_left = {{-1/2,3/16,-1/16,-1/8,5/16,1/16},
                {-1/2,-5/16,-1/16,-1/8,-3/16,1/16}},
            connect_back = {{-1/16,3/16,1/8,1/16,5/16,1/2},
                {-1/16,-5/16,1/8,1/16,-3/16,1/2}},
            connect_right = {{1/8,3/16,-1/16,1/2,5/16,1/16},
                {1/8,-5/16,-1/16,1/2,-3/16,1/16}},
        },
        connects_to = {"group:fence", "group:wood", "group:tree"},
        inventory_image = fence_texture,
        wield_image = fence_texture,
        tiles = {def.texture},
        sunlight_propagates = true,
        is_ground_content = false,
        groups = {},
    }
    for k, v in pairs(default_fields) do
        if not def[k] then
            def[k] = v
        end
    end

    -- Always add to the fence group, even if no group provided
    def.groups.fence = 1

    def.texture = nil
    def.material = nil

    minetest.register_node(name, def)
end

-- ===================================================================
-- Leaf decay
--

default.after_place_leaves = function (pos, placer,
    itemstack, pointed_thing)
end

-- ===================================================================

if enable_leaf_decay then
default.after_place_leaves = function (pos, placer,
    itemstack, pointed_thing)
    if placer and not placer:get_player_control().sneak then
        local node = minetest.get_node(pos)
        node.param2 = 1
        minetest.set_node(pos, node)
    end
end

-- ===================================================================

default.leafdecay_trunk_cache = {}
default.leafdecay_enable_cache = true

-- Spread the load of finding trunks
default.leafdecay_trunk_find_allow_accumulator = 0

minetest.register_globalstep(function(dtime)
    local finds_per_second = 5000
    default.leafdecay_trunk_find_allow_accumulator =
            math.floor(dtime * finds_per_second)
end)

-- ===================================================================

minetest.register_abm ({
    nodenames = {"group:leafdecay"},
    neighbors = {"air", "group:liquid"},

    -- A low interval and a high inverse chance spreads the load
    catch_up  = false ,
    chance    = 5     ,
    interval  = 2     ,

    action = function(p0, node, _, _)
        --print("leafdecay ABM at "..p0.x..", "..p0.y..", "..p0.z..")")
        local do_preserve = false
        local d = minetest.registered_nodes[node.name].groups.leafdecay
        if not d or d == 0 then
            --print("not groups.leafdecay")
            return
        end
        local n0 = minetest.get_node(p0)
        if n0.param2 ~= 0 then
            --print("param2 ~= 0")
            return
        end
        local p0_hash = nil
        if default.leafdecay_enable_cache then
            p0_hash = minetest.hash_node_position(p0)
            local trunkp = default.leafdecay_trunk_cache[p0_hash]
            if trunkp then
                local n = minetest.get_node(trunkp)
                local reg = minetest.registered_nodes[n.name]
                -- Assume ignore is a trunk, to make the thing
                -- work at the border of the active area
                if n.name == "ignore" or (reg and reg.groups.tree and
                        reg.groups.tree ~= 0) then
                    --print("cached trunk still exists")
                    return
                end
                --print("cached trunk is invalid")
                -- Cache is invalid
                table.remove(default.leafdecay_trunk_cache, p0_hash)
            end
        end
        if default.leafdecay_trunk_find_allow_accumulator <= 0 then
            return
        end
        default.leafdecay_trunk_find_allow_accumulator =
                default.leafdecay_trunk_find_allow_accumulator - 1
        -- Assume ignore is a trunk, to make the thing
        -- work at the border of the active area
        local p1 = minetest.find_node_near(p0, d, {"ignore", "group:tree"})
        if p1 then
            do_preserve = true
            if default.leafdecay_enable_cache then
                --print("caching trunk")
                -- Cache the trunk
                default.leafdecay_trunk_cache[p0_hash] = p1
            end
        end
        if not do_preserve then
            -- Drop stuff other than the node itself
            local itemstacks = minetest.get_node_drops(n0.name)
            for _, itemname in ipairs(itemstacks) do
                if minetest.get_item_group(n0.name, "leafdecay_drop") ~= 0 or
                        itemname ~= n0.name then
                    local p_drop = {
                        x = p0.x - 0.5 + math.random(),
                        y = p0.y - 0.5 + math.random(),
                        z = p0.z - 0.5 + math.random(),
                    }
                    minetest.add_item(p_drop, itemname)
                end
            end
            -- Remove node
            minetest.remove_node(p0)
            nodeupdate(p0)
        end
    end
})
end

-- ===================================================================
-- Convert dirt to something that fits the environment

minetest.register_abm ({
    nodenames = {"default:dirt"},

    neighbors = {
        "default:dirt_with_grass",
        "default:dirt_with_dry_grass",
        "default:dirt_with_snow",
        "group:grass",
        "group:dry_grass",
        "default:snow",
    } ,

    catch_up = false ,
    chance   = 67    ,
    interval =  6    ,

    action = function(pos, node)
        -- Most likely case, half the time it's too dark for this.
        local above = {x = pos.x, y = pos.y + 1, z = pos.z}
        if (minetest.get_node_light(above) or 0) < 13 then
            return
        end

        -- Look for likely neighbors.
        local p2 = minetest.find_node_near(pos, 1, {"default:dirt_with_grass",
                "default:dirt_with_dry_grass", "default:dirt_with_snow"})
        if p2 then
            -- But the node needs to be under air in this case.
            local n2 = minetest.get_node(above)
            if n2 and n2.name == "air" then
                local n3 = minetest.get_node(p2)
                minetest.set_node(pos, {name = n3.name})
                return
            end
        end

        -- Anything on top?
        local n2 = minetest.get_node(above)
        if not n2 then
            return
        end

        local name = n2.name
        -- Snow check is cheapest, so comes first.
        if name == "default:snow" then
            minetest.set_node(pos, {name = "default:dirt_with_snow"})
        -- Most likely case first.
        elseif minetest.get_item_group(name, "grass") ~= 0 then
            minetest.set_node(pos, {name = "default:dirt_with_grass"})
        elseif minetest.get_item_group(name, "dry_grass") ~= 0 then
            minetest.set_node(pos, {name = "default:dirt_with_dry_grass"})
        end
    end
})

-- ===================================================================
-- Grass and dry grass removed in darkness
--

minetest.register_abm({
    nodenames = {
        "default:dirt_with_grass",
        "default:dirt_with_dry_grass",
        "default:dirt_with_snow",
    } ,

    catch_up = false ,
    chance   = 50    ,
    interval =  8    ,

    action = function(pos, node)
        local above = {x = pos.x, y = pos.y + 1, z = pos.z}
        local name = minetest.get_node(above).name
        local nodedef = minetest.registered_nodes[name]
        if name ~= "ignore" and nodedef and not ((nodedef.sunlight_propagates or
                nodedef.paramtype == "light") and
                nodedef.liquidtype == "none") then
            minetest.set_node(pos, {name = "default:dirt"})
        end
    end
})

-- ===================================================================
-- Moss growth on cobble near water
--

minetest.register_abm({
    nodenames = {"default:cobble"},
    neighbors = {"group:water"},

    catch_up  = false ,
    chance    = 200   ,
    interval  =  16   ,

    action = function(pos, node)
        minetest.set_node(pos, {name = "default:mossycobble"})
    end
})

-- ===================================================================

function default.can_interact_with_node (player, pos)
    if player then
        if minetest.check_player_privs (player, "protection_bypass") then
            return true
        end
    else
        return false
    end

    local meta  = minetest.get_meta(pos)
    local owner = meta:get_string("owner")

    if not owner or owner == "" or owner == player:get_player_name() then
        return true
    end

    -- Is player wielding the right key?
    local item = player:get_wielded_item()
    if item:get_name() == "default:key" then
        local key_meta = item:get_meta()

        if key_meta:get_string("secret") == "" then
            local key_oldmeta = item:get_metadata()
            if key_oldmeta == "" or not minetest.parse_json(key_oldmeta) then
                return false
            end

            key_meta:set_string("secret", minetest.parse_json(key_oldmeta).secret)
            item:set_metadata("")
        end

        return meta:get_string("key_lock_secret") == key_meta:get_string("secret")
    end

    return false
end

-- ===================================================================
-- Fence rail registration helper
--

function default.register_fence_rail(name, def)
    minetest.register_craft({
        output = name .. " 16",
        recipe = {
            { def.material, def.material },
            { "", ""},
            { def.material, def.material },
        }
    })

    local fence_rail_texture = "default_fence_rail_overlay.png^" .. def.texture ..
            "^default_fence_rail_overlay.png^[makealpha:255,126,126"
    -- Allow almost everything to be overridden
    local default_fields = {
        paramtype = "light",
        drawtype = "nodebox",
        node_box = {
            type = "connected",
            fixed = {
                {-1/16,  3/16, -1/16, 1/16,  5/16, 1/16},
                {-1/16, -3/16, -1/16, 1/16, -5/16, 1/16}
            },
            -- connect_top =
            -- connect_bottom =
            connect_front = {
                {-1/16,  3/16, -1/2, 1/16,  5/16, -1/16},
                {-1/16, -5/16, -1/2, 1/16, -3/16, -1/16}},
            connect_left = {
                {-1/2,  3/16, -1/16, -1/16,  5/16, 1/16},
                {-1/2, -5/16, -1/16, -1/16, -3/16, 1/16}},
            connect_back = {
                {-1/16,  3/16, 1/16, 1/16,  5/16, 1/2},
                {-1/16, -5/16, 1/16, 1/16, -3/16, 1/2}},
            connect_right = {
                {1/16,  3/16, -1/16, 1/2,  5/16, 1/16},
                {1/16, -5/16, -1/16, 1/2, -3/16, 1/16}},
        },
        connects_to = {"group:fence", "group:wall"},
        inventory_image = fence_rail_texture,
        wield_image = fence_rail_texture,
        tiles = {def.texture},
        sunlight_propagates = true,
        is_ground_content = false,
        groups = {},
    }
    for k, v in pairs(default_fields) do
        if def[k] == nil then
            def[k] = v
        end
    end

    -- Always add to the fence group, even if no group provided
    def.groups.fence = 1

    def.texture = nil
    def.material = nil

    minetest.register_node(name, def)
end

-- ===================================================================
--
-- Mese post registration helper
--

function default.register_mesepost (name, def)

    minetest.register_craft ({
        output = name .. " 4" ,
        recipe = {
            { '', 'default:glass', '' } ,
            {
'default:mese_crystal' ,
'default:mese_crystal' ,
'default:mese_crystal'
            } ,
            {'' , def.material , '' } ,
        }
    })

    local post_texture      = def.texture ..
        "^default_mese_post_light_side.png^[makealpha:0,0,0"
    local post_texture_dark = def.texture ..
        "^default_mese_post_light_side_dark.png^[makealpha:0,0,0"

    -- Allow almost everything to be overridden

    local default_fields = {
        wield_image = post_texture,
        drawtype = "nodebox",
        node_box = {
            type = "fixed",
            fixed = {
                { -2/16, -8/16, -2/16, 2/16, 8/16, 2/16 } ,
            },
        },

        paramtype = "light",

        tiles = {
            def.texture,
            def.texture,
            post_texture_dark,
            post_texture_dark,
            post_texture,
            post_texture
        } ,

--      use_texture_alpha = "opaque",
        light_source = default.LIGHT_MAX,
        sunlight_propagates = true,
        is_ground_content = false,
        groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 2},
        sounds = default.node_sound_wood_defaults(),
    }

    for k, v in pairs (default_fields) do
        if  def [k] == nil then
            def [k] =  v
        end
    end

    def.texture  = nil
    def.material = nil
    minetest.register_node (name, def)
end

-- ===================================================================
-- End of file.