doors different colors. why are the inventory items white?

User avatar
Drachenbauer32
Member
 
Posts: 104
Joined: Wed Aug 28, 2019 18:11

doors different colors. why are the inventory items white?

by Drachenbauer32 » Sun Sep 29, 2019 19:58

Hello

i modifyed the existing doors-mod from the minetest game to have glass-doors with different colored frames.
the placed doors look alright.

But the inventory-items of my glass-doors stay white...

I use the overall color-value, that can be set by registering a node:
Code: Select all
color = value

"value" here means a color value from my colors-list, that i created in the code.

Code: Select all
function doors.register(name, def)

    -- replace old doors of this type automatically
    minetest.register_lbm({
        name = ":doors:replace_" .. name:gsub(":", "_"),
        nodenames = { name .. "_b_1", name .. "_b_2" },
        action = function(pos, node)
            local l = tonumber(node.name:sub(-1))
            local meta = minetest.get_meta(pos)
            local h = meta:get_int("right") + 1
            local p2 = node.param2
            local replace = {
                { { type = "a", state = 0 }, { type = "a", state = 3 } },
                { { type = "b", state = 1 }, { type = "b", state = 2 } }
            }
            local new = replace[l][h]
            -- retain infotext and doors_owner fields
            minetest.swap_node(pos, { name = name .. "_" .. new.type, param2 = p2 })
            meta:set_int("state", new.state)
            -- properly place doors:hidden at the right spot
            local p3 = p2
            if new.state >= 2 then
                p3 = (p3 + 3) % 4
            end
            if new.state % 2 == 1 then
                if new.state >= 2 then
                    p3 = (p3 + 1) % 4
                else
                    p3 = (p3 + 3) % 4
                end
            end
            -- wipe meta on top node as it's unused
            minetest.set_node({ x = pos.x, y = pos.y + 1, z = pos.z },
                { name = "doors:hidden", param2 = p3 })
        end
    })

    minetest.register_craftitem(":" .. name, {
        description = def.description,
        inventory_image = def.inventory_image,
        groups = table.copy(def.groups),
        on_place = function(itemstack, placer, pointed_thing)
            local pos

            if not pointed_thing.type == "node" then
                return itemstack
            end

            local node = minetest.get_node(pointed_thing.under)
            local pdef = minetest.registered_nodes[node.name]
            if pdef and pdef.on_rightclick and
                    not (placer and placer:is_player() and
                            placer:get_player_control().sneak) then
                return pdef.on_rightclick(pointed_thing.under,
                    node, placer, itemstack, pointed_thing)
            end

            if pdef and pdef.buildable_to then
                pos = pointed_thing.under
            else
                pos = pointed_thing.above
                node = minetest.get_node(pos)
                pdef = minetest.registered_nodes[node.name]
                if not pdef or not pdef.buildable_to then
                    return itemstack
                end
            end

            local above = { x = pos.x, y = pos.y + 1, z = pos.z }
            local top_node = minetest.get_node_or_nil(above)
            local topdef = top_node and minetest.registered_nodes[top_node.name]

            if not topdef or not topdef.buildable_to then
                return itemstack
            end

            local pn = placer and placer:get_player_name() or ""
            if minetest.is_protected(pos, pn) or minetest.is_protected(above, pn) then
                return itemstack
            end

            local dir = placer and minetest.dir_to_facedir(placer:get_look_dir()) or 0

            local ref = {
                { x = -1, y = 0, z = 0 },
                { x = 0, y = 0, z = 1 },
                { x = 1, y = 0, z = 0 },
                { x = 0, y = 0, z = -1 },
            }

            local aside = {
                x = pos.x + ref[dir + 1].x,
                y = pos.y + ref[dir + 1].y,
                z = pos.z + ref[dir + 1].z,
            }

            local state = 0
            if minetest.get_item_group(minetest.get_node(aside).name, "door") == 1 then
                state = state + 2
                minetest.set_node(pos, { name = name .. "_b", param2 = dir })
                minetest.set_node(above, { name = "doors:hidden", param2 = (dir + 3) % 4 })
            else
                minetest.set_node(pos, { name = name .. "_a", param2 = dir })
                minetest.set_node(above, { name = "doors:hidden", param2 = dir })
            end

            local meta = minetest.get_meta(pos)
            meta:set_int("state", state)

            if def.protected then
                meta:set_string("owner", pn)
                meta:set_string("infotext", "Owned by " .. pn)
            end

            if not (creative and creative.is_enabled_for and creative.is_enabled_for(pn)) then
                itemstack:take_item()
            end

            minetest.sound_play(def.sounds.place, { pos = pos })

            on_place_node(pos, minetest.get_node(pos),
                placer, node, itemstack, pointed_thing)

            return itemstack
        end
    })

    if def.recipe then
        minetest.register_craft({
            output = name,
            recipe = def.recipe,
        })
    end

    if not def.sounds then
        def.sounds = default.node_sound_wood_defaults()
    end

    if not def.sound_open then
        def.sound_open = "doors_door_open"
    end

    if not def.sound_close then
        def.sound_close = "doors_door_close"
    end

    def.groups.not_in_creative_inventory = 1
    def.groups.door = 1
    def.drop = name
    def.door = {
        name = name,
        sounds = { def.sound_close, def.sound_open },
    }
    if not def.on_rightclick then
        def.on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
            doors.door_toggle(pos, node, clicker)
            return itemstack
        end
    end
    def.after_dig_node = function(pos, node, meta, digger)
        minetest.remove_node({ x = pos.x, y = pos.y + 1, z = pos.z })
        minetest.check_for_falling({ x = pos.x, y = pos.y + 1, z = pos.z })
    end
    def.on_rotate = function(pos, node, user, mode, new_param2)
        return false
    end

    if def.protected then
        def.can_dig = can_dig_door
        def.on_blast = function() end
        def.on_key_use = function(pos, player)
            local door = doors.get(pos)
            door:toggle(player)
        end
        def.on_skeleton_key_use = function(pos, player, newsecret)
            replace_old_owner_information(pos)
            local meta = minetest.get_meta(pos)
            local owner = meta:get_string("owner")
            local pname = player:get_player_name()

            -- verify placer is owner of lockable door
            if owner ~= pname then
                minetest.record_protection_violation(pos, pname)
                minetest.chat_send_player(pname, "You do not own this locked door.")
                return nil
            end

            local secret = meta:get_string("key_lock_secret")
            if secret == "" then
                secret = newsecret
                meta:set_string("key_lock_secret", secret)
            end

            return secret, "a locked door", owner
        end
        def.node_dig_prediction = ""
    else
        def.on_blast = function(pos, intensity)
            minetest.remove_node(pos)
            -- hidden node doesn't get blasted away.
            minetest.remove_node({ x = pos.x, y = pos.y + 1, z = pos.z })
            return { name }
        end
    end

    def.on_destruct = function(pos)
        minetest.remove_node({ x = pos.x, y = pos.y + 1, z = pos.z })
    end

    def.drawtype = "mesh"
    def.paramtype = "light"
    def.paramtype2 = "facedir"
    def.sunlight_propagates = true
    def.walkable = true
    def.is_ground_content = false
    def.buildable_to = false
    def.selection_box = { type = "fixed", fixed = { -1 / 2, -1 / 2, -1 / 2, 1 / 2, 3 / 2, -6 / 16 } }
    def.collision_box = { type = "fixed", fixed = { -1 / 2, -1 / 2, -1 / 2, 1 / 2, 3 / 2, -6 / 16 } }

    def.mesh = "door_a.obj"
    minetest.register_node("doors:" .. name .. "_a", def)

    def.mesh = "door_b.obj"
    minetest.register_node("doors:" .. name .. "_b", def)

    doors.registered_doors[name .. "_a"] = true
    doors.registered_doors[name .. "_b"] = true
end

local dyes = {
    { "red", "Red", { a = 255, r = 255, g = 0, b = 0 } },
    { "orange", "Orange", { a = 255, r = 255, g = 127, b = 0 } },
    { "yellow", "Yellow", { a = 255, r = 255, g = 255, b = 0 } },
    { "green", "Green", { a = 255, r = 0, g = 255, b = 0 } },
    { "dark_green", "Dark-Green", { a = 255, r = 0, g = 191, b = 0 } },
    { "cyan", "Cyan", { a = 255, r = 0, g = 255, b = 255 } },
    { "light_blue", "Light-Blue", { a = 255, r = 0, g = 127, b = 255 } },
    { "blue", "Blue", { a = 255, r = 0, g = 0, b = 255 } },
    { "purple", "Purple", { a = 255, r = 159, g = 0, b = 255 } },
    { "magenta", "Magenta", { a = 255, r = 255, g = 0, b = 255 } },
    { "pink", "Pink", { a = 255, r = 255, g = 173, b = 183 } },
    { "brown", "Brown", { a = 255, r = 159, g = 127, b = 95 } },
    { "white", "White", { a = 255, r = 255, g = 255, b = 255 } },
    { "grey", "Grey", { a = 255, r = 191, g = 191, b = 191 } },
    { "dark_grey", "Dark-Grey", { a = 255, r = 127, g = 127, b = 127 } },
    { "black", "Black", { a = 255, r = 95, g = 95, b = 95 } }
}

for i = 1, #dyes do
    local name, description, dye = unpack(dyes[i])

    doors.register("door_glass_" .. name, {
        description = description .. " Glass Door",
        color = dye,
        tiles = { "doors_door_glass.png" },
        overlay_tiles = {
            { name = "doors_door_glass_overlay.png", color = "white" },
        },
        inventory_image = "doors_item_glass.png",
        wield_image = "doors_item_glass.png",
        groups = { cracky = 3, oddly_breakable_by_hand = 3 },
        sounds = default.node_sound_glass_defaults(),
        sound_open = "doors_glass_door_open",
        sound_close = "doors_glass_door_close",
        recipe = {
            { "default:glass_" .. name, "default:glass_" .. name },
            { "default:glass_" .. name, "default:glass_" .. name },
            { "default:glass_" .. name, "default:glass_" .. name },
        },
    })
end


it literates through the colors-list to generate 16 different colored doors.

normaly that colors the texture of the placed model and the inventory and wield image.
But here it´s not the case.
I don´t know why?
 

User avatar
Nathan.S
Member
 
Posts: 924
Joined: Wed Sep 24, 2014 17:47
Location: Bigsby Texas
GitHub: NathanSalapat
IRC: NathanS21
In-game: NathanS21

Re: doors different colors. why are the inventory items whit

by Nathan.S » Sun Sep 29, 2019 23:11

Code: Select all
inventory_image = "doors_item_glass.png",
wield_image = "doors_item_glass.png",

These two lines define the inventory and wield textures, and they are both set to item_glass. You need to either do a colorize effect on them or something similar to get them all to match the colors of the placed doors.
I record Minetest videos, Mod reviews, Modding tutorials, and Lets plays.
Check out my website, and brand new Minetest Modding Course
 

User avatar
Drachenbauer32
Member
 
Posts: 104
Joined: Wed Aug 28, 2019 18:11

Re: doors different colors. why are the inventory items whit

by Drachenbauer32 » Mon Sep 30, 2019 17:34

at my other multi color-nodes the overall color value
Code: Select all
color = dye,
colors theese images automaticly, too.
 

User avatar
Nathan.S
Member
 
Posts: 924
Joined: Wed Sep 24, 2014 17:47
Location: Bigsby Texas
GitHub: NathanSalapat
IRC: NathanS21
In-game: NathanS21

Re: doors different colors. why are the inventory items whit

by Nathan.S » Tue Oct 01, 2019 02:16

Your other nodes likely do not use those two images, but auto generate them from the node. Doors are two nodes tall, so they need custom inventory and wield images to display in a sane fashion when held in hand, or viewed in player inventory.
I record Minetest videos, Mod reviews, Modding tutorials, and Lets plays.
Check out my website, and brand new Minetest Modding Course
 

User avatar
Drachenbauer32
Member
 
Posts: 104
Joined: Wed Aug 28, 2019 18:11

Re: doors different colors. why are the inventory items whit

by Drachenbauer32 » Tue Oct 01, 2019 21:19

i have other nodes with custom images for inventory and wield (for sample: beds, butterflies) and the color value acts for theese images and the textures of the model, there.
Last edited by Drachenbauer32 on Thu Oct 03, 2019 21:33, edited 1 time in total.
 

User avatar
Nathan.S
Member
 
Posts: 924
Joined: Wed Sep 24, 2014 17:47
Location: Bigsby Texas
GitHub: NathanSalapat
IRC: NathanS21
In-game: NathanS21

Re: doors different colors. why are the inventory items whit

by Nathan.S » Wed Oct 02, 2019 02:07

If it's working in another mod, but not here, and you're doing the same stuff in code, I don't know what the problem is.
I record Minetest videos, Mod reviews, Modding tutorials, and Lets plays.
Check out my website, and brand new Minetest Modding Course
 

User avatar
Napiophelios
Member
 
Posts: 985
Joined: Mon Jul 07, 2014 01:14
GitHub: Napiophelios
IRC: Nappi
In-game: Nappi
 

User avatar
Drachenbauer32
Member
 
Posts: 104
Joined: Wed Aug 28, 2019 18:11

Re: doors different colors. why are the inventory items whit

by Drachenbauer32 » Thu Oct 03, 2019 21:34

is for the butterfly also not used.

now i noticed, that an extra-item (minetest.register_craftitem) is registred for the door, instead of using the node directly as the inventory item like at the butterfly.
That was it
 

User avatar
Drachenbauer32
Member
 
Posts: 104
Joined: Wed Aug 28, 2019 18:11

Re: doors different colors. why are the inventory items whit

by Drachenbauer32 » Sun Oct 06, 2019 19:40

But now i noticed, i cannot more open and close doors.

Here is my actual code:
Code: Select all
-- our API object
doors = {}

doors.registered_doors = {}
doors.registered_trapdoors = {}

local function replace_old_owner_information(pos)
    local meta = minetest.get_meta(pos)
    local owner = meta:get_string("doors_owner")
    if owner and owner ~= "" then
        meta:set_string("owner", owner)
        meta:set_string("doors_owner", "")
    end
end

-- returns an object to a door object or nil
function doors.get(pos)
    local node_name = minetest.get_node(pos).name
    if doors.registered_doors[node_name] then
        -- A normal upright door
        return {
            pos = pos,
            open = function(self, player)
                if self:state() then
                    return false
                end
                return doors.door_toggle(self.pos, nil, player)
            end,
            close = function(self, player)
                if not self:state() then
                    return false
                end
                return doors.door_toggle(self.pos, nil, player)
            end,
            toggle = function(self, player)
                return doors.door_toggle(self.pos, nil, player)
            end,
            state = function(self)
                local state = minetest.get_meta(self.pos):get_int("state")
                return state % 2 == 1
            end
        }
    elseif doors.registered_trapdoors[node_name] then
        -- A trapdoor
        return {
            pos = pos,
            open = function(self, player)
                if self:state() then
                    return false
                end
                return doors.trapdoor_toggle(self.pos, nil, player)
            end,
            close = function(self, player)
                if not self:state() then
                    return false
                end
                return doors.trapdoor_toggle(self.pos, nil, player)
            end,
            toggle = function(self, player)
                return doors.trapdoor_toggle(self.pos, nil, player)
            end,
            state = function(self)
                return minetest.get_node(self.pos).name:sub(-5) == "_open"
            end
        }
    else
        return nil
    end
end

-- this hidden node is placed on top of the bottom, and prevents
-- nodes from being placed in the top half of the door.
minetest.register_node("doors:hidden", {
    description = "Hidden Door Segment",
    -- can't use airlike otherwise falling nodes will turn to entities
    -- and will be forever stuck until door is removed.
    drawtype = "nodebox",
    paramtype = "light",
    paramtype2 = "facedir",
    sunlight_propagates = true,
    -- has to be walkable for falling nodes to stop falling.
    walkable = true,
    pointable = false,
    diggable = false,
    buildable_to = false,
    floodable = false,
    drop = "",
    groups = { not_in_creative_inventory = 1 },
    on_blast = function() end,
    tiles = { "doors_blank.png" },
    -- 1px transparent block inside door hinge near node top.
    node_box = {
        type = "fixed",
        fixed = { -15 / 32, 13 / 32, -15 / 32, -13 / 32, 1 / 2, -13 / 32 },
    },
    -- collision_box needed otherise selection box would be full node size
    collision_box = {
        type = "fixed",
        fixed = { -15 / 32, 13 / 32, -15 / 32, -13 / 32, 1 / 2, -13 / 32 },
    },
})

-- table used to aid door opening/closing
local transform = {
    {
        { v = "_a", param2 = 3 },
        { v = "_a", param2 = 0 },
        { v = "_a", param2 = 1 },
        { v = "_a", param2 = 2 },
    },
    {
        { v = "_b", param2 = 1 },
        { v = "_b", param2 = 2 },
        { v = "_b", param2 = 3 },
        { v = "_b", param2 = 0 },
    },
    {
        { v = "_b", param2 = 1 },
        { v = "_b", param2 = 2 },
        { v = "_b", param2 = 3 },
        { v = "_b", param2 = 0 },
    },
    {
        { v = "_a", param2 = 3 },
        { v = "_a", param2 = 0 },
        { v = "_a", param2 = 1 },
        { v = "_a", param2 = 2 },
    },
}

function doors.door_toggle(pos, node, clicker)
    local meta = minetest.get_meta(pos)
    node = node or minetest.get_node(pos)
    local def = minetest.registered_nodes[node.name]
    local name = def.door.name

    local state = meta:get_string("state")
    if state == "" then
        -- fix up lvm-placed right-hinged doors, default closed
        if node.name:sub(-2) == "_b" then
            state = 2
        else
            state = 0
        end
    else
        state = tonumber(state)
    end

    replace_old_owner_information(pos)

    if clicker and not default.can_interact_with_node(clicker, pos) then
        return false
    end

    -- until Lua-5.2 we have no bitwise operators :(
    if state % 2 == 1 then
        state = state - 1
    else
        state = state + 1
    end

    local dir = node.param2

    -- It's possible param2 is messed up, so, validate before using
    -- the input data. This indicates something may have rotated
    -- the door, even though that is not supported.
    if not transform[state + 1] or not transform[state + 1][dir + 1] then
        return false
    end

    if state % 2 == 0 then
        minetest.sound_play(def.door.sounds[1],
            { pos = pos, gain = 0.3, max_hear_distance = 10 })
    else
        minetest.sound_play(def.door.sounds[2],
            { pos = pos, gain = 0.3, max_hear_distance = 10 })
    end

    minetest.swap_node(pos, {
        name = name .. transform[state + 1][dir + 1].v,
        param2 = transform[state + 1][dir + 1].param2
    })
    meta:set_int("state", state)

    return true
end


local function on_place_node(place_to, newnode,
placer, oldnode, itemstack, pointed_thing)
    -- Run script hook
    for _, callback in ipairs(minetest.registered_on_placenodes) do
        -- Deepcopy pos, node and pointed_thing because callback can modify them
        local place_to_copy = { x = place_to.x, y = place_to.y, z = place_to.z }
        local newnode_copy =
        { name = newnode.name, param1 = newnode.param1, param2 = newnode.param2 }
        local oldnode_copy =
        { name = oldnode.name, param1 = oldnode.param1, param2 = oldnode.param2 }
        local pointed_thing_copy = {
            type = pointed_thing.type,
            above = vector.new(pointed_thing.above),
            under = vector.new(pointed_thing.under),
            ref = pointed_thing.ref,
        }
        callback(place_to_copy, newnode_copy, placer,
            oldnode_copy, itemstack, pointed_thing_copy)
    end
end

local function can_dig_door(pos, digger)
    replace_old_owner_information(pos)
    return default.can_interact_with_node(digger, pos)
end

function doors.register(name, def)

    -- replace old doors of this type automatically
    minetest.register_lbm({
        name = ":doors:replace_" .. name:gsub(":", "_"),
        nodenames = { name .. "_b_1", name .. "_b_2" },
        action = function(pos, node)
            local l = tonumber(node.name:sub(-1))
            local meta = minetest.get_meta(pos)
            local h = meta:get_int("right") + 1
            local p2 = node.param2
            local replace = {
                { { type = "a", state = 0 }, { type = "a", state = 3 } },
                { { type = "b", state = 1 }, { type = "b", state = 2 } }
            }
            local new = replace[l][h]
            -- retain infotext and doors_owner fields
            minetest.swap_node(pos, { name = name .. "_" .. new.type, param2 = p2 })
            meta:set_int("state", new.state)
            -- properly place doors:hidden at the right spot
            local p3 = p2
            if new.state >= 2 then
                p3 = (p3 + 3) % 4
            end
            if new.state % 2 == 1 then
                if new.state >= 2 then
                    p3 = (p3 + 1) % 4
                else
                    p3 = (p3 + 3) % 4
                end
            end
            -- wipe meta on top node as it's unused
            minetest.set_node({ x = pos.x, y = pos.y + 1, z = pos.z },
                { name = "doors:hidden", param2 = p3 })
        end
    })

    minetest.register_craftitem("doors:" .. name, {
        description = def.description,
        color = def.color,
        inventory_image = def.inventory_image,
        inventory_overlay = def.inventory_overlay,
        groups = table.copy(def.groups),
        on_place = function(itemstack, placer, pointed_thing)
            local pos

            if not pointed_thing.type == "node" then
                return itemstack
            end

            local node = minetest.get_node(pointed_thing.under)
            local pdef = minetest.registered_nodes[node.name]
            if pdef and pdef.on_rightclick and
                    not (placer and placer:is_player() and
                            placer:get_player_control().sneak) then
                return pdef.on_rightclick(pointed_thing.under,
                    node, placer, itemstack, pointed_thing)
            end

            if pdef and pdef.buildable_to then
                pos = pointed_thing.under
            else
                pos = pointed_thing.above
                node = minetest.get_node(pos)
                pdef = minetest.registered_nodes[node.name]
                if not pdef or not pdef.buildable_to then
                    return itemstack
                end
            end

            local above = { x = pos.x, y = pos.y + 1, z = pos.z }
            local top_node = minetest.get_node_or_nil(above)
            local topdef = top_node and minetest.registered_nodes[top_node.name]

            if not topdef or not topdef.buildable_to then
                return itemstack
            end

            local pn = placer and placer:get_player_name() or ""
            if minetest.is_protected(pos, pn) or minetest.is_protected(above, pn) then
                return itemstack
            end

            local dir = placer and minetest.dir_to_facedir(placer:get_look_dir()) or 0

            local ref = {
                { x = -1, y = 0, z = 0 },
                { x = 0, y = 0, z = 1 },
                { x = 1, y = 0, z = 0 },
                { x = 0, y = 0, z = -1 },
            }

            local aside = {
                x = pos.x + ref[dir + 1].x,
                y = pos.y + ref[dir + 1].y,
                z = pos.z + ref[dir + 1].z,
            }

            local state = 0
            if minetest.get_item_group(minetest.get_node(aside).name, "door") == 1 then
                state = state + 2
                minetest.set_node(pos, { name = "doors:" .. name .. "_b", param2 = dir })
                minetest.set_node(above, { name = "doors:hidden", param2 = (dir + 3) % 4 })
            else
                minetest.set_node(pos, { name = "doors:" .. name .. "_a", param2 = dir })
                minetest.set_node(above, { name = "doors:hidden", param2 = dir })
            end

            local meta = minetest.get_meta(pos)
            meta:set_int("state", state)

            if def.protected then
                meta:set_string("owner", pn)
                meta:set_string("infotext", "Owned by " .. pn)
            end

            if not (creative and creative.is_enabled_for and creative.is_enabled_for(pn)) then
                itemstack:take_item()
            end

            minetest.sound_play(def.sounds.place, { pos = pos })

            on_place_node(pos, minetest.get_node(pos),
                placer, node, itemstack, pointed_thing)

            return itemstack
        end
    })

    if def.recipe then
        minetest.register_craft({
            output = name,
            recipe = def.recipe,
        })
    end

    if not def.sounds then
        def.sounds = default.node_sound_wood_defaults()
    end

    if not def.sound_open then
        def.sound_open = "doors_door_open"
    end

    if not def.sound_close then
        def.sound_close = "doors_door_close"
    end

    def.groups.not_in_creative_inventory = 1
    def.groups.door = 1
    def.drop = name
    def.door = {
        name = name,
        sounds = { def.sound_close, def.sound_open },
    }
    if not def.on_rightclick then
        def.on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
            doors.door_toggle(pos, node, clicker)
            return itemstack
        end
    end
    def.after_dig_node = function(pos, node, meta, digger)
        minetest.remove_node({ x = pos.x, y = pos.y + 1, z = pos.z })
        minetest.check_for_falling({ x = pos.x, y = pos.y + 1, z = pos.z })
    end
    def.on_rotate = function(pos, node, user, mode, new_param2)
        return false
    end

    if def.protected then
        def.can_dig = can_dig_door
        def.on_blast = function() end
        def.on_key_use = function(pos, player)
            local door = doors.get(pos)
            door:toggle(player)
        end
        def.on_skeleton_key_use = function(pos, player, newsecret)
            replace_old_owner_information(pos)
            local meta = minetest.get_meta(pos)
            local owner = meta:get_string("owner")
            local pname = player:get_player_name()

            -- verify placer is owner of lockable door
            if owner ~= pname then
                minetest.record_protection_violation(pos, pname)
                minetest.chat_send_player(pname, "You do not own this locked door.")
                return nil
            end

            local secret = meta:get_string("key_lock_secret")
            if secret == "" then
                secret = newsecret
                meta:set_string("key_lock_secret", secret)
            end

            return secret, "a locked door", owner
        end
        def.node_dig_prediction = ""
    else
        def.on_blast = function(pos, intensity)
            minetest.remove_node(pos)
            -- hidden node doesn't get blasted away.
            minetest.remove_node({ x = pos.x, y = pos.y + 1, z = pos.z })
            return { name }
        end
    end

    def.on_destruct = function(pos)
        minetest.remove_node({ x = pos.x, y = pos.y + 1, z = pos.z })
    end

    def.drawtype = "mesh"
    def.paramtype = "light"
    def.paramtype2 = "facedir"
    def.sunlight_propagates = true
    def.walkable = true
    def.is_ground_content = false
    def.buildable_to = false
    def.selection_box = { type = "fixed", fixed = { -1 / 2, -1 / 2, -1 / 2, 1 / 2, 3 / 2, -6 / 16 } }
    def.collision_box = { type = "fixed", fixed = { -1 / 2, -1 / 2, -1 / 2, 1 / 2, 3 / 2, -6 / 16 } }

    def.mesh = "door_a.obj"
    minetest.register_node("doors:" .. name .. "_a", def)

    def.mesh = "door_b.obj"
    minetest.register_node("doors:" .. name .. "_b", def)

    doors.registered_doors[name .. "_a"] = true
    doors.registered_doors[name .. "_b"] = true
end

doors.register("door_wood", {
    description = "Wooden Door",
    color = "white",
    tiles = { { name = "doors_door_wood.png", backface_culling = true } },
    inventory_image = "doors_item_wood.png",
    groups = { choppy = 2, oddly_breakable_by_hand = 2, flammable = 2 },
    recipe = {
        { "group:wood", "group:wood" },
        { "group:wood", "group:wood" },
        { "group:wood", "group:wood" },
    }
})

doors.register("door_steel", {
    description = "Steel Door",
    color = "white",
    tiles = { { name = "doors_door_steel.png", backface_culling = true } },
    inventory_image = "doors_item_steel.png",
    protected = true,
    groups = { cracky = 1, level = 2 },
    sounds = default.node_sound_metal_defaults(),
    sound_open = "doors_steel_door_open",
    sound_close = "doors_steel_door_close",
    recipe = {
        { "default:steel_ingot", "default:steel_ingot" },
        { "default:steel_ingot", "default:steel_ingot" },
        { "default:steel_ingot", "default:steel_ingot" },
    }
})

local dyes = {
    {"red",        "Red",        {a=255, r=255, g=  0, b=  0}},
    {"orange",     "Orange",     {a=255, r=255, g=127, b=  0}},
    {"yellow",     "Yellow",     {a=255, r=255, g=255, b=  0}},
    {"green",      "Green",      {a=255, r=  0, g=255, b=  0}},
    {"dark_green", "Dark-Green", {a=255, r=  0, g=191, b=  0}},
    {"cyan",       "Cyan",       {a=255, r=  0, g=255, b=255}},
    {"light_blue", "Light-Blue", {a=255, r=  0, g=127, b=255}},
    {"blue",       "Blue",       {a=255, r=  0, g=  0, b=255}},
    {"purple",     "Purple",     {a=255, r=159, g=  0, b=255}},
    {"magenta",    "Magenta",    {a=255, r=255, g=  0, b=255}},
    {"pink",       "Pink",       {a=255, r=255, g=173, b=183}},
    {"brown",      "Brown",      {a=255, r=159, g=127, b= 95}},
    {"white",      "White",      {a=255, r=255, g=255, b=255}},
    {"grey",       "Grey",       {a=255, r=191, g=191, b=191}},
    {"dark_grey",  "Dark-Grey",  {a=255, r=127, g=127, b=127}},
    {"black",      "Black",      {a=255, r= 95, g= 95, b= 95}}
}

for i = 1, #dyes do
    local name, description, dye = unpack(dyes[i])

    doors.register("door_glass_" .. name, {
        description = description .. " Glass Door",
        color = dye,
        tiles = { "doors_door_glass.png" },
        overlay_tiles = {
            { name = "doors_door_glass_overlay.png", color = "white" },
        },
        inventory_image = "doors_item_glass.png",
        inventory_overlay = "doors_item_glass_overlay.png",
        groups = { cracky = 3, oddly_breakable_by_hand = 3 },
        sounds = default.node_sound_glass_defaults(),
        sound_open = "doors_glass_door_open",
        sound_close = "doors_glass_door_close",
        recipe = {
            { "default:glass_" .. name, "default:glass_" .. name },
            { "default:glass_" .. name, "default:glass_" .. name },
            { "default:glass_" .. name, "default:glass_" .. name },
        },
    })
end

doors.register("door_obsidian_glass", {
    description = "Obsidian Glass Door",
    tiles = { "doors_door_obsidian_glass.png" },
    color = "white",
    inventory_image = "doors_item_obsidian_glass.png",
    groups = { cracky = 3 },
    sounds = default.node_sound_glass_defaults(),
    sound_open = "doors_glass_door_open",
    sound_close = "doors_glass_door_close",
    recipe = {
        { "default:obsidian_glass", "default:obsidian_glass" },
        { "default:obsidian_glass", "default:obsidian_glass" },
        { "default:obsidian_glass", "default:obsidian_glass" },
    },
})

-- Capture mods using the old API as best as possible.
function doors.register_door(name, def)
    if def.only_placer_can_open then
        def.protected = true
    end
    def.only_placer_can_open = nil

    local i = name:find(":")
    local modname = name:sub(1, i - 1)
    if not def.tiles then
        if def.protected then
            def.tiles = { { name = "doors_door_steel.png", backface_culling = true } }
        else
            def.tiles = { { name = "doors_door_wood.png", backface_culling = true } }
        end
        minetest.log("warning", modname .. " registered door \"" .. name .. "\" " ..
                "using deprecated API method \"doors.register_door()\" but " ..
                "did not provide the \"tiles\" parameter. A fallback tiledef " ..
                "will be used instead.")
    end

    doors.register(name, def)
end

--- -trapdoor----
function doors.trapdoor_toggle(pos, node, clicker)
    node = node or minetest.get_node(pos)

    replace_old_owner_information(pos)

    if clicker and not default.can_interact_with_node(clicker, pos) then
        return false
    end

    local def = minetest.registered_nodes[node.name]

    if string.sub(node.name, -5) == "_open" then
        minetest.sound_play(def.sound_close,
            { pos = pos, gain = 0.3, max_hear_distance = 10 })
        minetest.swap_node(pos, {
            name = string.sub(node.name, 1,
                string.len(node.name) - 5),
            param1 = node.param1,
            param2 = node.param2
        })
    else
        minetest.sound_play(def.sound_open,
            { pos = pos, gain = 0.3, max_hear_distance = 10 })
        minetest.swap_node(pos, {
            name = node.name .. "_open",
            param1 = node.param1,
            param2 = node.param2
        })
    end
end

function doors.register_trapdoor(name, def)
    if not name:find(":") then
        name = "doors:" .. name
    end

    local name_closed = name
    local name_opened = name .. "_open"

    def.on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
        doors.trapdoor_toggle(pos, node, clicker)
        return itemstack
    end

    -- Common trapdoor configuration
    def.drawtype = "nodebox"
    def.paramtype = "light"
    def.paramtype2 = "facedir"
    def.is_ground_content = false

    if def.protected then
        def.can_dig = can_dig_door
        def.after_place_node = function(pos, placer, itemstack, pointed_thing)
            local pn = placer:get_player_name()
            local meta = minetest.get_meta(pos)
            meta:set_string("owner", pn)
            meta:set_string("infotext", "Owned by " .. pn)

            return (creative and creative.is_enabled_for and creative.is_enabled_for(pn))
        end

        def.on_blast = function() end
        def.on_key_use = function(pos, player)
            local door = doors.get(pos)
            door:toggle(player)
        end
        def.on_skeleton_key_use = function(pos, player, newsecret)
            replace_old_owner_information(pos)
            local meta = minetest.get_meta(pos)
            local owner = meta:get_string("owner")
            local pname = player:get_player_name()

            -- verify placer is owner of lockable door
            if owner ~= pname then
                minetest.record_protection_violation(pos, pname)
                minetest.chat_send_player(pname, "You do not own this trapdoor.")
                return nil
            end

            local secret = meta:get_string("key_lock_secret")
            if secret == "" then
                secret = newsecret
                meta:set_string("key_lock_secret", secret)
            end

            return secret, "a locked trapdoor", owner
        end
        def.node_dig_prediction = ""
    else
        def.on_blast = function(pos, intensity)
            minetest.remove_node(pos)
            return { name }
        end
    end

    if not def.sounds then
        def.sounds = default.node_sound_wood_defaults()
    end

    if not def.sound_open then
        def.sound_open = "doors_door_open"
    end

    if not def.sound_close then
        def.sound_close = "doors_door_close"
    end

    local def_opened = table.copy(def)
    local def_closed = table.copy(def)

    def_closed.node_box = {
        type = "fixed",
        fixed = { -0.5, -0.5, -0.5, 0.5, -6 / 16, 0.5 }
    }
    def_closed.selection_box = {
        type = "fixed",
        fixed = { -0.5, -0.5, -0.5, 0.5, -6 / 16, 0.5 }
    }
    def_closed.tiles = {
        def.tile_front,
        def.tile_front .. '^[transformFY',
        def.tile_side, def.tile_side,
        def.tile_side, def.tile_side
    }

    def_opened.node_box = {
        type = "fixed",
        fixed = { -0.5, -0.5, 6 / 16, 0.5, 0.5, 0.5 }
    }
    def_opened.selection_box = {
        type = "fixed",
        fixed = { -0.5, -0.5, 6 / 16, 0.5, 0.5, 0.5 }
    }
    def_opened.tiles = {
        def.tile_side, def.tile_side,
        def.tile_side .. '^[transform3',
        def.tile_side .. '^[transform1',
        def.tile_front .. '^[transform46',
        def.tile_front .. '^[transform6'
    }

    def_opened.drop = name_closed
    def_opened.groups.not_in_creative_inventory = 1

    minetest.register_node(name_opened, def_opened)
    minetest.register_node(name_closed, def_closed)

    doors.registered_trapdoors[name_opened] = true
    doors.registered_trapdoors[name_closed] = true
end

doors.register_trapdoor("doors:trapdoor", {
    description = "Wooden Trapdoor",
    inventory_image = "doors_trapdoor.png",
    wield_image = "doors_trapdoor.png",
    tile_front = "doors_trapdoor.png",
    tile_side = "doors_trapdoor_side.png",
    groups = { choppy = 2, oddly_breakable_by_hand = 2, flammable = 2, door = 1 },
})

doors.register_trapdoor("doors:trapdoor_steel", {
    description = "Steel Trapdoor",
    inventory_image = "doors_trapdoor_steel.png",
    wield_image = "doors_trapdoor_steel.png",
    tile_front = "doors_trapdoor_steel.png",
    tile_side = "doors_trapdoor_steel_side.png",
    protected = true,
    sounds = default.node_sound_metal_defaults(),
    sound_open = "doors_steel_door_open",
    sound_close = "doors_steel_door_close",
    groups = { cracky = 1, level = 2, door = 1 },
})

minetest.register_craft({
    output = 'doors:trapdoor 2',
    recipe = {
        { 'group:wood', 'group:wood', 'group:wood' },
        { 'group:wood', 'group:wood', 'group:wood' },
        { '', '', '' },
    }
})

minetest.register_craft({
    output = 'doors:trapdoor_steel',
    recipe = {
        { 'default:steel_ingot', 'default:steel_ingot' },
        { 'default:steel_ingot', 'default:steel_ingot' },
    }
})


--- -fence gate----
function doors.register_fencegate(name, def)
    local fence = {
        description = def.description,
        drawtype = "mesh",
        tiles = {},
        paramtype = "light",
        paramtype2 = "facedir",
        sunlight_propagates = true,
        is_ground_content = false,
        drop = name .. "_closed",
        connect_sides = { "left", "right" },
        groups = def.groups,
        sounds = def.sounds,
        on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
            local node_def = minetest.registered_nodes[node.name]
            minetest.swap_node(pos, { name = node_def.gate, param2 = node.param2 })
            minetest.sound_play(node_def.sound, {
                pos = pos,
                gain = 0.3,
                max_hear_distance = 8
            })
            return itemstack
        end,
        selection_box = {
            type = "fixed",
            fixed = { -1 / 2, -1 / 2, -1 / 4, 1 / 2, 1 / 2, 1 / 4 },
        },
    }


    if type(def.texture) == "string" then
        fence.tiles[1] = { name = def.texture, backface_culling = true }
    elseif def.texture.backface_culling == nil then
        fence.tiles[1] = table.copy(def.texture)
        fence.tiles[1].backface_culling = true
    else
        fence.tiles[1] = def.texture
    end

    if not fence.sounds then
        fence.sounds = default.node_sound_wood_defaults()
    end

    fence.groups.fence = 1

    local fence_closed = table.copy(fence)
    fence_closed.mesh = "doors_fencegate_closed.obj"
    fence_closed.gate = name .. "_open"
    fence_closed.sound = "doors_fencegate_open"
    fence_closed.collision_box = {
        type = "fixed",
        fixed = { -1 / 2, -1 / 2, -1 / 4, 1 / 2, 1 / 2, 1 / 4 },
    }

    local fence_open = table.copy(fence)
    fence_open.mesh = "doors_fencegate_open.obj"
    fence_open.gate = name .. "_closed"
    fence_open.sound = "doors_fencegate_close"
    fence_open.groups.not_in_creative_inventory = 1
    fence_open.collision_box = {
        type = "fixed",
        fixed = {
            { -1 / 2, -1 / 2, -1 / 4, -3 / 8, 1 / 2, 1 / 4 },
            { -1 / 2, -3 / 8, -1 / 2, -3 / 8, 3 / 8, 0 }
        },
    }

    minetest.register_node(":" .. name .. "_closed", fence_closed)
    minetest.register_node(":" .. name .. "_open", fence_open)

    minetest.register_craft({
        output = name .. "_closed",
        recipe = {
            { "default:stick", def.material, "default:stick" },
            { "default:stick", def.material, "default:stick" }
        }
    })
end

doors.register_fencegate("doors:gate_wood", {
    description = "Apple Wood Fence Gate",
    texture = "default_wood.png",
    material = "default:wood",
    groups = { choppy = 2, oddly_breakable_by_hand = 2, flammable = 2 }
})

doors.register_fencegate("doors:gate_acacia_wood", {
    description = "Acacia Wood Fence Gate",
    texture = "default_acacia_wood.png",
    material = "default:acacia_wood",
    groups = { choppy = 2, oddly_breakable_by_hand = 2, flammable = 2 }
})

doors.register_fencegate("doors:gate_junglewood", {
    description = "Jungle Wood Fence Gate",
    texture = "default_junglewood.png",
    material = "default:junglewood",
    groups = { choppy = 2, oddly_breakable_by_hand = 2, flammable = 2 }
})

doors.register_fencegate("doors:gate_pine_wood", {
    description = "Pine Wood Fence Gate",
    texture = "default_pine_wood.png",
    material = "default:pine_wood",
    groups = { choppy = 3, oddly_breakable_by_hand = 2, flammable = 3 }
})

doors.register_fencegate("doors:gate_aspen_wood", {
    description = "Aspen Wood Fence Gate",
    texture = "default_aspen_wood.png",
    material = "default:aspen_wood",
    groups = { choppy = 3, oddly_breakable_by_hand = 2, flammable = 3 }
})


--- -fuels----

minetest.register_craft({
    type = "fuel",
    recipe = "doors:trapdoor",
    burntime = 7,
})

minetest.register_craft({
    type = "fuel",
    recipe = "doors:door_wood",
    burntime = 14,
})

minetest.register_craft({
    type = "fuel",
    recipe = "doors:gate_wood_closed",
    burntime = 7,
})

minetest.register_craft({
    type = "fuel",
    recipe = "doors:gate_acacia_wood_closed",
    burntime = 8,
})

minetest.register_craft({
    type = "fuel",
    recipe = "doors:gate_junglewood_closed",
    burntime = 9,
})

minetest.register_craft({
    type = "fuel",
    recipe = "doors:gate_pine_wood_closed",
    burntime = 6,
})

minetest.register_craft({
    type = "fuel",
    recipe = "doors:gate_aspen_wood_closed",
    burntime = 5,
})


if i rightclick a door, it says:
Map::setNode(): Not allowing to place CONTENT_IGNORE while trying to replace "doors:door_glass_yellow_a"


I can place a door, but not open or close it...

What´s the mistake?
 


Return to Modding Discussion



Who is online

Users browsing this forum: No registered users and 2 guests