minetest/minetest_game
1
0
Fork 2
mirror of https://github.com/minetest/minetest_game.git synced 2024-11-16 06:50:18 +01:00
Code Issues Releases Wiki Activity
62d5d5954e
minetest_game/mods/doors/init.lua

867 lines
23 KiB
Lua
Raw Normal View History

New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
-- our API object
doors = {}
-- private data
local _doors = {}
_doors.registered_doors = {}
_doors.registered_trapdoors = {}
Change doors to default.can_interact_with_node()
2017-02-21 19:43:34 +01:00
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
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
-- returns an object to a door object or nil
function doors.get(pos)
Doors: Remove unnecessary node lookups
2016-07-02 02:30:45 +02:00
local node_name = minetest.get_node(pos).name
if _doors.registered_doors[node_name] then
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
-- A normal upright door
return {
pos = pos,
open = function(self, player)
if self:state() then
return false
end
Doors: Fix missing node parameter passing
2016-07-11 17:50:19 +02:00
return _doors.door_toggle(self.pos, nil, player)
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
end,
close = function(self, player)
if not self:state() then
return false
end
Doors: Fix missing node parameter passing
2016-07-11 17:50:19 +02:00
return _doors.door_toggle(self.pos, nil, player)
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
end,
toggle = function(self, player)
Doors: Fix missing node parameter passing
2016-07-11 17:50:19 +02:00
return _doors.door_toggle(self.pos, nil, player)
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
end,
state = function(self)
local state = minetest.get_meta(self.pos):get_int("state")
return state %2 == 1
end
}
Doors: Remove unnecessary node lookups
2016-07-02 02:30:45 +02:00
elseif _doors.registered_trapdoors[node_name] then
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
-- A trapdoor
return {
pos = pos,
open = function(self, player)
if self:state() then
return false
end
Doors: Fix missing node parameter passing
2016-07-11 17:50:19 +02:00
return _doors.trapdoor_toggle(self.pos, nil, player)
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
end,
close = function(self, player)
if not self:state() then
return false
end
Doors: Fix missing node parameter passing
2016-07-11 17:50:19 +02:00
return _doors.trapdoor_toggle(self.pos, nil, player)
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
end,
toggle = function(self, player)
Doors: Fix missing node parameter passing
2016-07-11 17:50:19 +02:00
return _doors.trapdoor_toggle(self.pos, nil, player)
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
end,
state = function(self)
Doors: Fix missing node parameter passing
2016-07-11 17:50:19 +02:00
return minetest.get_node(self.pos).name:sub(-5) == "_open"
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
end
}
else
return nil
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
end
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
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",
Doors: Allow falling nodes to fall onto doors. We were cleverly attempting to use an airlike node as the top half of the doors, but as airlike nodes are not walkable, falling nodes would not stop falling and thus remain an entity stuck on top of a door. After inspecting the builtin/game/falling.lua code, I considered the remaining options: (a) revert doors such that the top part is actually the door, (b) play with nodedef fields and see if other flags may work, or (c) modify the hidden door part to another drawtype that properly prevents this issue. (a) seemed way over the top for now, although it would solve the issue, it would cause a rewrite of most of the code including the old-door-conversion. (b) turned up nothing. (c) turned out to be relatively simple. So, here's the implementation where I turn the hidden door top into a tiny, non-targetable but walkable nodebox that is entirely inside the door hinge. It's entirely transparent, so you still can't see it, can't hit it, nor can you place anything in it or make liquids flow through it. The top part is placed in the right position on placement and not touched further. Falling nodes will properly stop on top of these doors. I've adjusted the door conversion code to properly account for the issue as well, so the only thing remaining is people who have been running a git branch - those can upgrade by re-placing the door.
2016-03-15 05:27:32 +01:00
-- can't use airlike otherwise falling nodes will turn to entities
-- and will be forever stuck until door is removed.
drawtype = "nodebox",
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
paramtype = "light",
Doors: Allow falling nodes to fall onto doors. We were cleverly attempting to use an airlike node as the top half of the doors, but as airlike nodes are not walkable, falling nodes would not stop falling and thus remain an entity stuck on top of a door. After inspecting the builtin/game/falling.lua code, I considered the remaining options: (a) revert doors such that the top part is actually the door, (b) play with nodedef fields and see if other flags may work, or (c) modify the hidden door part to another drawtype that properly prevents this issue. (a) seemed way over the top for now, although it would solve the issue, it would cause a rewrite of most of the code including the old-door-conversion. (b) turned up nothing. (c) turned out to be relatively simple. So, here's the implementation where I turn the hidden door top into a tiny, non-targetable but walkable nodebox that is entirely inside the door hinge. It's entirely transparent, so you still can't see it, can't hit it, nor can you place anything in it or make liquids flow through it. The top part is placed in the right position on placement and not touched further. Falling nodes will properly stop on top of these doors. I've adjusted the door conversion code to properly account for the issue as well, so the only thing remaining is people who have been running a git branch - those can upgrade by re-placing the door.
2016-03-15 05:27:32 +01:00
paramtype2 = "facedir",
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
sunlight_propagates = true,
Doors: Allow falling nodes to fall onto doors. We were cleverly attempting to use an airlike node as the top half of the doors, but as airlike nodes are not walkable, falling nodes would not stop falling and thus remain an entity stuck on top of a door. After inspecting the builtin/game/falling.lua code, I considered the remaining options: (a) revert doors such that the top part is actually the door, (b) play with nodedef fields and see if other flags may work, or (c) modify the hidden door part to another drawtype that properly prevents this issue. (a) seemed way over the top for now, although it would solve the issue, it would cause a rewrite of most of the code including the old-door-conversion. (b) turned up nothing. (c) turned out to be relatively simple. So, here's the implementation where I turn the hidden door top into a tiny, non-targetable but walkable nodebox that is entirely inside the door hinge. It's entirely transparent, so you still can't see it, can't hit it, nor can you place anything in it or make liquids flow through it. The top part is placed in the right position on placement and not touched further. Falling nodes will properly stop on top of these doors. I've adjusted the door conversion code to properly account for the issue as well, so the only thing remaining is people who have been running a git branch - those can upgrade by re-placing the door.
2016-03-15 05:27:32 +01:00
-- has to be walkable for falling nodes to stop falling.
walkable = true,
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
pointable = false,
diggable = false,
buildable_to = false,
floodable = false,
drop = "",
Doors: Allow falling nodes to fall onto doors. We were cleverly attempting to use an airlike node as the top half of the doors, but as airlike nodes are not walkable, falling nodes would not stop falling and thus remain an entity stuck on top of a door. After inspecting the builtin/game/falling.lua code, I considered the remaining options: (a) revert doors such that the top part is actually the door, (b) play with nodedef fields and see if other flags may work, or (c) modify the hidden door part to another drawtype that properly prevents this issue. (a) seemed way over the top for now, although it would solve the issue, it would cause a rewrite of most of the code including the old-door-conversion. (b) turned up nothing. (c) turned out to be relatively simple. So, here's the implementation where I turn the hidden door top into a tiny, non-targetable but walkable nodebox that is entirely inside the door hinge. It's entirely transparent, so you still can't see it, can't hit it, nor can you place anything in it or make liquids flow through it. The top part is placed in the right position on placement and not touched further. Falling nodes will properly stop on top of these doors. I've adjusted the door conversion code to properly account for the issue as well, so the only thing remaining is people who have been running a git branch - those can upgrade by re-placing the door.
2016-03-15 05:27:32 +01:00
groups = {not_in_creative_inventory = 1},
on_blast = function() end,
tiles = {"doors_blank.png"},
-- 1px transparent block inside door hinge near node top.
nodebox -> node_box Seems like this was a typo
2017-04-12 22:27:58 +02:00
node_box = {
Doors: Allow falling nodes to fall onto doors. We were cleverly attempting to use an airlike node as the top half of the doors, but as airlike nodes are not walkable, falling nodes would not stop falling and thus remain an entity stuck on top of a door. After inspecting the builtin/game/falling.lua code, I considered the remaining options: (a) revert doors such that the top part is actually the door, (b) play with nodedef fields and see if other flags may work, or (c) modify the hidden door part to another drawtype that properly prevents this issue. (a) seemed way over the top for now, although it would solve the issue, it would cause a rewrite of most of the code including the old-door-conversion. (b) turned up nothing. (c) turned out to be relatively simple. So, here's the implementation where I turn the hidden door top into a tiny, non-targetable but walkable nodebox that is entirely inside the door hinge. It's entirely transparent, so you still can't see it, can't hit it, nor can you place anything in it or make liquids flow through it. The top part is placed in the right position on placement and not touched further. Falling nodes will properly stop on top of these doors. I've adjusted the door conversion code to properly account for the issue as well, so the only thing remaining is people who have been running a git branch - those can upgrade by re-placing the door.
2016-03-15 05:27:32 +01:00
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},
},
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
})
-- table used to aid door opening/closing
local transform = {
{
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
{v = "_a", param2 = 3},
{v = "_a", param2 = 0},
{v = "_a", param2 = 1},
{v = "_a", param2 = 2},
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
},
{
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
{v = "_b", param2 = 1},
{v = "_b", param2 = 2},
{v = "_b", param2 = 3},
{v = "_b", param2 = 0},
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
},
{
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
{v = "_b", param2 = 1},
{v = "_b", param2 = 2},
{v = "_b", param2 = 3},
{v = "_b", param2 = 0},
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
},
{
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
{v = "_a", param2 = 3},
{v = "_a", param2 = 0},
{v = "_a", param2 = 1},
{v = "_a", param2 = 2},
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
},
}
Doors: Remove unnecessary node lookups
2016-07-02 02:30:45 +02:00
function _doors.door_toggle(pos, node, clicker)
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
local meta = minetest.get_meta(pos)
Doors: Fix missing node parameter passing
2016-07-11 17:50:19 +02:00
node = node or minetest.get_node(pos)
Doors: Remove unnecessary node lookups
2016-07-02 02:30:45 +02:00
local def = minetest.registered_nodes[node.name]
Allow mod namespace for door registrations. This is an adapted version of #861 - by oleastre Most mods had been calling `doors.register_door() with a door name that included the "modname:" prefix, and we should continue to allow mods to do so, without registering the nodenames created in the "doors:" namespace. The default case is to use the "modname:" prefix verbatim. If mods or code calls this function without a prefix, then "doors:" is automatically used. Now that the namespace is corrected, the copy replacement ABM is no longer needed.
2016-02-21 05:03:09 +01:00
local name = def.door.name
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
Doors: Allow schematic placement of wooden doors. If LVM or some other nonmetadata method is used to place a door, then metadata is missing that tells us whether the door is left or right-hinged. However, we can detect that nodemeta is missing and see if the node name is _a or _b. In the case of _a, nothing needs to be done and we can just open the door. In the case of _b we assume the door is right hinged, and tune the state nodemeta value so that the door opens the right way. This all of course assumes that the schematic method places the doors *closed* by default, which is reasonable.
2016-03-21 07:48:16 +01:00
local state = meta:get_string("state")
if state == "" then
-- fix up lvm-placed right-hinged doors, default closed
Doors: Remove unnecessary node lookups
2016-07-02 02:30:45 +02:00
if node.name:sub(-2) == "_b" then
Doors: Allow schematic placement of wooden doors. If LVM or some other nonmetadata method is used to place a door, then metadata is missing that tells us whether the door is left or right-hinged. However, we can detect that nodemeta is missing and see if the node name is _a or _b. In the case of _a, nothing needs to be done and we can just open the door. In the case of _b we assume the door is right hinged, and tune the state nodemeta value so that the door opens the right way. This all of course assumes that the schematic method places the doors *closed* by default, which is reasonable.
2016-03-21 07:48:16 +01:00
state = 2
Doors: Fix uninitialized state variable
2016-05-21 15:45:55 +02:00
else
state = 0
Doors: Allow schematic placement of wooden doors. If LVM or some other nonmetadata method is used to place a door, then metadata is missing that tells us whether the door is left or right-hinged. However, we can detect that nodemeta is missing and see if the node name is _a or _b. In the case of _a, nothing needs to be done and we can just open the door. In the case of _b we assume the door is right hinged, and tune the state nodemeta value so that the door opens the right way. This all of course assumes that the schematic method places the doors *closed* by default, which is reasonable.
2016-03-21 07:48:16 +01:00
end
else
state = tonumber(state)
end
Change doors to default.can_interact_with_node()
2017-02-21 19:43:34 +01:00
replace_old_owner_information(pos)
Keys: Show owner in description Utilizes several new features allowing the description of an item to be changed using the `description` meta key. This also moves keys from using the old single-value itemstack metadata system to the new node-like metadata system.
2017-02-26 18:24:12 +01:00
Doors: Ignore permission check if player parameter is omitted As written in game_api.txt.
2017-04-17 12:56:27 +02:00
if clicker and not default.can_interact_with_node(clicker, pos) then
Change doors to default.can_interact_with_node()
2017-02-21 19:43:34 +01:00
return false
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
end
Remove trailing whitespace from doors
2014-02-13 00:06:45 +01:00
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
-- until Lua-5.2 we have no bitwise operators :(
if state % 2 == 1 then
state = state - 1
else
state = state + 1
Add API doors : Sound for door open and close.
2014-08-04 18:28:09 +02:00
end
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
Doors: Remove unnecessary node lookups
2016-07-02 02:30:45 +02:00
local dir = node.param2
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
if state % 2 == 0 then
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
minetest.sound_play(def.door.sounds[1],
{pos = pos, gain = 0.3, max_hear_distance = 10})
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
else
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
minetest.sound_play(def.door.sounds[2],
{pos = pos, gain = 0.3, max_hear_distance = 10})
Add API doors : Sound for door open and close.
2014-08-04 18:28:09 +02:00
end
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
minetest.swap_node(pos, {
Allow mod namespace for door registrations. This is an adapted version of #861 - by oleastre Most mods had been calling `doors.register_door() with a door name that included the "modname:" prefix, and we should continue to allow mods to do so, without registering the nodenames created in the "doors:" namespace. The default case is to use the "modname:" prefix verbatim. If mods or code calls this function without a prefix, then "doors:" is automatically used. Now that the namespace is corrected, the copy replacement ABM is no longer needed.
2016-02-21 05:03:09 +01:00
name = name .. transform[state + 1][dir+1].v,
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
param2 = transform[state + 1][dir+1].param2
})
meta:set_int("state", state)
return true
end
Call on_place_node() callbacks after placing door. Other mods may depend on knowing whether doors are placed to setup additional attributes or perform node manipulations. This is something e.g. mesecons does to connect circuits to doors. This was tested with mesecons. Placing a door next to a mesecon wire will make the wire automatically connect, which was otherwise not happening.
2016-02-14 21:21:51 +01:00
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
local function on_place_node(place_to, newnode,
placer, oldnode, itemstack, pointed_thing)
Call on_place_node() callbacks after placing door. Other mods may depend on knowing whether doors are placed to setup additional attributes or perform node manipulations. This is something e.g. mesecons does to connect circuits to doors. This was tested with mesecons. Placing a door next to a mesecon wire will make the wire automatically connect, which was otherwise not happening.
2016-02-14 21:21:51 +01:00
-- Run script hook
Use minetest instead of core namespace, discourage via luacheck
2016-08-05 14:55:43 +02:00
for _, callback in ipairs(minetest.registered_on_placenodes) do
Call on_place_node() callbacks after placing door. Other mods may depend on knowing whether doors are placed to setup additional attributes or perform node manipulations. This is something e.g. mesecons does to connect circuits to doors. This was tested with mesecons. Placing a door next to a mesecon wire will make the wire automatically connect, which was otherwise not happening.
2016-02-14 21:21:51 +01:00
-- 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}
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
local newnode_copy =
{name = newnode.name, param1 = newnode.param1, param2 = newnode.param2}
local oldnode_copy =
{name = oldnode.name, param1 = oldnode.param1, param2 = oldnode.param2}
Call on_place_node() callbacks after placing door. Other mods may depend on knowing whether doors are placed to setup additional attributes or perform node manipulations. This is something e.g. mesecons does to connect circuits to doors. This was tested with mesecons. Placing a door next to a mesecon wire will make the wire automatically connect, which was otherwise not happening.
2016-02-14 21:21:51 +01:00
local pointed_thing_copy = {
type = pointed_thing.type,
above = vector.new(pointed_thing.above),
under = vector.new(pointed_thing.under),
ref = pointed_thing.ref,
}
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
callback(place_to_copy, newnode_copy, placer,
oldnode_copy, itemstack, pointed_thing_copy)
Call on_place_node() callbacks after placing door. Other mods may depend on knowing whether doors are placed to setup additional attributes or perform node manipulations. This is something e.g. mesecons does to connect circuits to doors. This was tested with mesecons. Placing a door next to a mesecon wire will make the wire automatically connect, which was otherwise not happening.
2016-02-14 21:21:51 +01:00
end
end
Doors: Fix potential crashes, code improvements Fix crash when doors are placed under unknown nodes. Share a can_dig among doors, that does not crash on nil-player. Only set can_dig if we actually protect the door.
2016-07-30 14:21:30 +02:00
local function can_dig_door(pos, digger)
Change doors to default.can_interact_with_node()
2017-02-21 19:43:34 +01:00
replace_old_owner_information(pos)
doors: record protection violation if it cannot be dug
2017-03-25 17:18:17 +01:00
if default.can_interact_with_node(digger, pos) then
return true
else
minetest.record_protection_violation(pos, digger:get_player_name())
return false
end
Doors: Fix potential crashes, code improvements Fix crash when doors are placed under unknown nodes. Share a can_dig among doors, that does not crash on nil-player. Only set can_dig if we actually protect the door.
2016-07-30 14:21:30 +02:00
end
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
function doors.register(name, def)
Allow mod namespace for door registrations. This is an adapted version of #861 - by oleastre Most mods had been calling `doors.register_door() with a door name that included the "modname:" prefix, and we should continue to allow mods to do so, without registering the nodenames created in the "doors:" namespace. The default case is to use the "modname:" prefix verbatim. If mods or code calls this function without a prefix, then "doors:" is automatically used. Now that the namespace is corrected, the copy replacement ABM is no longer needed.
2016-02-21 05:03:09 +01:00
if not name:find(":") then
name = "doors:" .. name
end
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
-- replace old doors of this type automatically
Doors: Use LBM instead of ABM to convert doors. This works much more efficiently to replace old style doors.
2016-04-16 05:55:56 +02:00
minetest.register_lbm({
name = ":doors:replace_" .. name:gsub(":", "_"),
Allow mod namespace for door registrations. This is an adapted version of #861 - by oleastre Most mods had been calling `doors.register_door() with a door name that included the "modname:" prefix, and we should continue to allow mods to do so, without registering the nodenames created in the "doors:" namespace. The default case is to use the "modname:" prefix verbatim. If mods or code calls this function without a prefix, then "doors:" is automatically used. Now that the namespace is corrected, the copy replacement ABM is no longer needed.
2016-02-21 05:03:09 +01:00
nodenames = {name.."_b_1", name.."_b_2"},
Doors: Use LBM instead of ABM to convert doors. This works much more efficiently to replace old style doors.
2016-04-16 05:55:56 +02:00
action = function(pos, node)
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
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 = {
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
{{type = "a", state = 0}, {type = "a", state = 3}},
{{type = "b", state = 1}, {type = "b", state = 2}}
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
}
local new = replace[l][h]
-- retain infotext and doors_owner fields
Allow mod namespace for door registrations. This is an adapted version of #861 - by oleastre Most mods had been calling `doors.register_door() with a door name that included the "modname:" prefix, and we should continue to allow mods to do so, without registering the nodenames created in the "doors:" namespace. The default case is to use the "modname:" prefix verbatim. If mods or code calls this function without a prefix, then "doors:" is automatically used. Now that the namespace is corrected, the copy replacement ABM is no longer needed.
2016-02-21 05:03:09 +01:00
minetest.swap_node(pos, {name = name .. "_" .. new.type, param2 = p2})
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
meta:set_int("state", new.state)
Doors: Allow falling nodes to fall onto doors. We were cleverly attempting to use an airlike node as the top half of the doors, but as airlike nodes are not walkable, falling nodes would not stop falling and thus remain an entity stuck on top of a door. After inspecting the builtin/game/falling.lua code, I considered the remaining options: (a) revert doors such that the top part is actually the door, (b) play with nodedef fields and see if other flags may work, or (c) modify the hidden door part to another drawtype that properly prevents this issue. (a) seemed way over the top for now, although it would solve the issue, it would cause a rewrite of most of the code including the old-door-conversion. (b) turned up nothing. (c) turned out to be relatively simple. So, here's the implementation where I turn the hidden door top into a tiny, non-targetable but walkable nodebox that is entirely inside the door hinge. It's entirely transparent, so you still can't see it, can't hit it, nor can you place anything in it or make liquids flow through it. The top part is placed in the right position on placement and not touched further. Falling nodes will properly stop on top of these doors. I've adjusted the door conversion code to properly account for the issue as well, so the only thing remaining is people who have been running a git branch - those can upgrade by re-placing the door.
2016-03-15 05:27:32 +01:00
-- 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
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
-- wipe meta on top node as it's unused
Doors: Allow falling nodes to fall onto doors. We were cleverly attempting to use an airlike node as the top half of the doors, but as airlike nodes are not walkable, falling nodes would not stop falling and thus remain an entity stuck on top of a door. After inspecting the builtin/game/falling.lua code, I considered the remaining options: (a) revert doors such that the top part is actually the door, (b) play with nodedef fields and see if other flags may work, or (c) modify the hidden door part to another drawtype that properly prevents this issue. (a) seemed way over the top for now, although it would solve the issue, it would cause a rewrite of most of the code including the old-door-conversion. (b) turned up nothing. (c) turned out to be relatively simple. So, here's the implementation where I turn the hidden door top into a tiny, non-targetable but walkable nodebox that is entirely inside the door hinge. It's entirely transparent, so you still can't see it, can't hit it, nor can you place anything in it or make liquids flow through it. The top part is placed in the right position on placement and not touched further. Falling nodes will properly stop on top of these doors. I've adjusted the door conversion code to properly account for the issue as well, so the only thing remaining is people who have been running a git branch - those can upgrade by re-placing the door.
2016-03-15 05:27:32 +01:00
minetest.set_node({x = pos.x, y = pos.y + 1, z = pos.z},
{name = "doors:hidden", param2 = p3})
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
end
})
Allow mod namespace for door registrations. This is an adapted version of #861 - by oleastre Most mods had been calling `doors.register_door() with a door name that included the "modname:" prefix, and we should continue to allow mods to do so, without registering the nodenames created in the "doors:" namespace. The default case is to use the "modname:" prefix verbatim. If mods or code calls this function without a prefix, then "doors:" is automatically used. Now that the namespace is corrected, the copy replacement ABM is no longer needed.
2016-02-21 05:03:09 +01:00
minetest.register_craftitem(":" .. name, {
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
description = def.description,
inventory_image = def.inventory_image,
doors: Fix craftitem not listed in inventory (#1683) Fixes bug caused by b847888
2017-04-02 10:01:01 +02:00
groups = table.copy(def.groups),
Remove trailing whitespace from doors
2014-02-13 00:06:45 +01:00
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
on_place = function(itemstack, placer, pointed_thing)
Remove unused and clean up missused variable-value assignments. * Unused variables * Unused values (assigned to variables, but overwritten before use) * Defining already defined variables instead of reassigning to them.
2016-06-26 13:34:14 +02:00
local pos
Allow building doors on buildable_to nodes. This code never allowed placing a door on e.g. a grass plant. The code to handle this isn't that complex. With this code, doors can be placed on flowers and on normal node surfaces without issues.
2016-02-14 05:00:37 +01:00
Open doors when right-clicking a door with a door. And similarly, if we wield a door and right click any node that has an on_rightclick() handler, call the handler instead. Just to be on the safe side, assure that none of this code runs when right-clicking an entity or player, which would likely crash the server. Fold in PR #831 as well - prevent server crash on door place on unknown blocks, by @tenplus1.
2016-02-14 05:27:03 +01:00
if not pointed_thing.type == "node" then
return itemstack
end
Allow building doors on buildable_to nodes. This code never allowed placing a door on e.g. a grass plant. The code to handle this isn't that complex. With this code, doors can be placed on flowers and on normal node surfaces without issues.
2016-02-14 05:00:37 +01:00
local node = minetest.get_node(pointed_thing.under)
Fix broken door protection. A previous fix overwrote the `def` variable during registration, causing protected doors no longer to be placed with protection.
2016-02-20 09:41:22 +01:00
local pdef = minetest.registered_nodes[node.name]
Make doors place when shift is held instead of calling on_rightclick Fixes #1364
2017-01-03 17:54:01 +01:00
if pdef and pdef.on_rightclick and
Add nil checks for placer
2017-10-01 15:41:58 +02:00
not (placer and placer:is_player() and
placer:get_player_control().sneak) then
Fix broken door protection. A previous fix overwrote the `def` variable during registration, causing protected doors no longer to be placed with protection.
2016-02-20 09:41:22 +01:00
return pdef.on_rightclick(pointed_thing.under,
Doors: Pass pointed_thing to on_rightclick() callback This is an omission technicality. The callee should be able to trust this isn't `nil`
2016-05-30 01:46:34 +02:00
node, placer, itemstack, pointed_thing)
Open doors when right-clicking a door with a door. And similarly, if we wield a door and right click any node that has an on_rightclick() handler, call the handler instead. Just to be on the safe side, assure that none of this code runs when right-clicking an entity or player, which would likely crash the server. Fold in PR #831 as well - prevent server crash on door place on unknown blocks, by @tenplus1.
2016-02-14 05:27:03 +01:00
end
Fix broken door protection. A previous fix overwrote the `def` variable during registration, causing protected doors no longer to be placed with protection.
2016-02-20 09:41:22 +01:00
if pdef and pdef.buildable_to then
Allow building doors on buildable_to nodes. This code never allowed placing a door on e.g. a grass plant. The code to handle this isn't that complex. With this code, doors can be placed on flowers and on normal node surfaces without issues.
2016-02-14 05:00:37 +01:00
pos = pointed_thing.under
else
pos = pointed_thing.above
node = minetest.get_node(pos)
Fix broken door protection. A previous fix overwrote the `def` variable during registration, causing protected doors no longer to be placed with protection.
2016-02-20 09:41:22 +01:00
pdef = minetest.registered_nodes[node.name]
if not pdef or not pdef.buildable_to then
Open doors when right-clicking a door with a door. And similarly, if we wield a door and right click any node that has an on_rightclick() handler, call the handler instead. Just to be on the safe side, assure that none of this code runs when right-clicking an entity or player, which would likely crash the server. Fold in PR #831 as well - prevent server crash on door place on unknown blocks, by @tenplus1.
2016-02-14 05:27:03 +01:00
return itemstack
end
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
end
Add protection support to doors
2014-02-13 00:05:16 +01:00
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
local above = {x = pos.x, y = pos.y + 1, z = pos.z}
Doors: Fix potential crashes, code improvements Fix crash when doors are placed under unknown nodes. Share a can_dig among doors, that does not crash on nil-player. Only set can_dig if we actually protect the door.
2016-07-30 14:21:30 +02:00
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
Add protection support to doors
2014-02-13 00:05:16 +01:00
return itemstack
end
Remove trailing whitespace from doors
2014-02-13 00:06:45 +01:00
Add nil checks for placer
2017-10-01 15:41:58 +02:00
local pn = placer and placer:get_player_name() or ""
Doors: Prevent placement in protected areas. https://forum.minetest.net/viewtopic.php?f=42&t=1523&start=500#p208773 Currently, doors can be placed inside others' protected areas. We need to check protection for both bottom and top halves.
2016-02-29 17:35:36 +01:00
if minetest.is_protected(pos, pn) or minetest.is_protected(above, pn) then
return itemstack
end
Add nil checks for placer
2017-10-01 15:41:58 +02:00
local dir = placer and minetest.dir_to_facedir(placer:get_look_dir()) or 0
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
local ref = {
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
{x = -1, y = 0, z = 0},
{x = 0, y = 0, z = 1},
{x = 1, y = 0, z = 0},
{x = 0, y = 0, z = -1},
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
}
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
Allow mod namespace for door registrations. This is an adapted version of #861 - by oleastre Most mods had been calling `doors.register_door() with a door name that included the "modname:" prefix, and we should continue to allow mods to do so, without registering the nodenames created in the "doors:" namespace. The default case is to use the "modname:" prefix verbatim. If mods or code calls this function without a prefix, then "doors:" is automatically used. Now that the namespace is corrected, the copy replacement ABM is no longer needed.
2016-02-21 05:03:09 +01:00
minetest.set_node(pos, {name = name .. "_b", param2 = dir})
Doors: Allow falling nodes to fall onto doors. We were cleverly attempting to use an airlike node as the top half of the doors, but as airlike nodes are not walkable, falling nodes would not stop falling and thus remain an entity stuck on top of a door. After inspecting the builtin/game/falling.lua code, I considered the remaining options: (a) revert doors such that the top part is actually the door, (b) play with nodedef fields and see if other flags may work, or (c) modify the hidden door part to another drawtype that properly prevents this issue. (a) seemed way over the top for now, although it would solve the issue, it would cause a rewrite of most of the code including the old-door-conversion. (b) turned up nothing. (c) turned out to be relatively simple. So, here's the implementation where I turn the hidden door top into a tiny, non-targetable but walkable nodebox that is entirely inside the door hinge. It's entirely transparent, so you still can't see it, can't hit it, nor can you place anything in it or make liquids flow through it. The top part is placed in the right position on placement and not touched further. Falling nodes will properly stop on top of these doors. I've adjusted the door conversion code to properly account for the issue as well, so the only thing remaining is people who have been running a git branch - those can upgrade by re-placing the door.
2016-03-15 05:27:32 +01:00
minetest.set_node(above, {name = "doors:hidden", param2 = (dir + 3) % 4})
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
else
Allow mod namespace for door registrations. This is an adapted version of #861 - by oleastre Most mods had been calling `doors.register_door() with a door name that included the "modname:" prefix, and we should continue to allow mods to do so, without registering the nodenames created in the "doors:" namespace. The default case is to use the "modname:" prefix verbatim. If mods or code calls this function without a prefix, then "doors:" is automatically used. Now that the namespace is corrected, the copy replacement ABM is no longer needed.
2016-02-21 05:03:09 +01:00
minetest.set_node(pos, {name = name .. "_a", param2 = dir})
Doors: Allow falling nodes to fall onto doors. We were cleverly attempting to use an airlike node as the top half of the doors, but as airlike nodes are not walkable, falling nodes would not stop falling and thus remain an entity stuck on top of a door. After inspecting the builtin/game/falling.lua code, I considered the remaining options: (a) revert doors such that the top part is actually the door, (b) play with nodedef fields and see if other flags may work, or (c) modify the hidden door part to another drawtype that properly prevents this issue. (a) seemed way over the top for now, although it would solve the issue, it would cause a rewrite of most of the code including the old-door-conversion. (b) turned up nothing. (c) turned out to be relatively simple. So, here's the implementation where I turn the hidden door top into a tiny, non-targetable but walkable nodebox that is entirely inside the door hinge. It's entirely transparent, so you still can't see it, can't hit it, nor can you place anything in it or make liquids flow through it. The top part is placed in the right position on placement and not touched further. Falling nodes will properly stop on top of these doors. I've adjusted the door conversion code to properly account for the issue as well, so the only thing remaining is people who have been running a git branch - those can upgrade by re-placing the door.
2016-03-15 05:27:32 +01:00
minetest.set_node(above, {name = "doors:hidden", param2 = dir})
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
end
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
local meta = minetest.get_meta(pos)
meta:set_int("state", state)
Remove trailing whitespace from doors
2014-02-13 00:06:45 +01:00
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
if def.protected then
Change doors to default.can_interact_with_node()
2017-02-21 19:43:34 +01:00
meta:set_string("owner", pn)
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
meta:set_string("infotext", "Owned by " .. pn)
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
end
Remove trailing whitespace from doors
2014-02-13 00:06:45 +01:00
Use creative.is_enabled_for for creative mode if possible (#1558)
2017-03-29 21:02:26 +02:00
if not (creative and creative.is_enabled_for and creative.is_enabled_for(pn)) then
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
itemstack:take_item()
end
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
Doors: place sound when placing a door. Due to door items being the thing that's placed, we need to explicitly play a sound when placing a door. Fixes #1363
2017-04-29 06:09:07 +02:00
minetest.sound_play(def.sounds.place, {pos = pos})
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
on_place_node(pos, minetest.get_node(pos),
placer, node, itemstack, pointed_thing)
Call on_place_node() callbacks after placing door. Other mods may depend on knowing whether doors are placed to setup additional attributes or perform node manipulations. This is something e.g. mesecons does to connect circuits to doors. This was tested with mesecons. Placing a door next to a mesecon wire will make the wire automatically connect, which was otherwise not happening.
2016-02-14 21:21:51 +01:00
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
return itemstack
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
end
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
})
Doors: Clean up nodedef usage Allows for more properties to be passed through. Somewhat simplifies the code as well.
2016-03-13 01:12:37 +01:00
def.inventory_image = nil
if def.recipe then
minetest.register_craft({
output = name,
recipe = def.recipe,
})
end
def.recipe = nil
Remove trailing whitespace from doors
2014-02-13 00:06:45 +01:00
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
if not def.sounds then
def.sounds = default.node_sound_wood_defaults()
Make TNT respect on_blast, implement on_blast for some nodes Implemented nodes: - Steel Door: Ignores explosion - Locked Chest: Ignores explosion - Fire: Ignores explosion - TNT: Starts burning - Burning TNT: Explodes immediately - Gunpowder: Starts burning - Burning Gunpowder: Ignores explosion
2015-03-07 08:32:00 +01:00
end
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
if not def.sound_open then
def.sound_open = "doors_door_open"
Make TNT respect on_blast, implement on_blast for some nodes Implemented nodes: - Steel Door: Ignores explosion - Locked Chest: Ignores explosion - Fire: Ignores explosion - TNT: Starts burning - Burning TNT: Explodes immediately - Gunpowder: Starts burning - Burning Gunpowder: Ignores explosion
2015-03-07 08:32:00 +01:00
end
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
if not def.sound_close then
def.sound_close = "doors_door_close"
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
end
Remove trailing whitespace from doors
2014-02-13 00:06:45 +01:00
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
def.groups.not_in_creative_inventory = 1
def.groups.door = 1
Allow mod namespace for door registrations. This is an adapted version of #861 - by oleastre Most mods had been calling `doors.register_door() with a door name that included the "modname:" prefix, and we should continue to allow mods to do so, without registering the nodenames created in the "doors:" namespace. The default case is to use the "modname:" prefix verbatim. If mods or code calls this function without a prefix, then "doors:" is automatically used. Now that the namespace is corrected, the copy replacement ABM is no longer needed.
2016-02-21 05:03:09 +01:00
def.drop = name
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
def.door = {
Allow mod namespace for door registrations. This is an adapted version of #861 - by oleastre Most mods had been calling `doors.register_door() with a door name that included the "modname:" prefix, and we should continue to allow mods to do so, without registering the nodenames created in the "doors:" namespace. The default case is to use the "modname:" prefix verbatim. If mods or code calls this function without a prefix, then "doors:" is automatically used. Now that the namespace is corrected, the copy replacement ABM is no longer needed.
2016-02-21 05:03:09 +01:00
name = name,
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
sounds = { def.sound_close, def.sound_open },
}
Remove trailing whitespace from doors
2014-02-13 00:06:45 +01:00
Always return the leftover ItemStack for on_place and on_rightclick
2016-07-01 22:43:02 +02:00
def.on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
Doors: Remove unnecessary node lookups
2016-07-02 02:30:45 +02:00
_doors.door_toggle(pos, node, clicker)
Always return the leftover ItemStack for on_place and on_rightclick
2016-07-01 22:43:02 +02:00
return itemstack
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
end
def.after_dig_node = function(pos, node, meta, digger)
Doors: Allow falling nodes to fall onto doors. We were cleverly attempting to use an airlike node as the top half of the doors, but as airlike nodes are not walkable, falling nodes would not stop falling and thus remain an entity stuck on top of a door. After inspecting the builtin/game/falling.lua code, I considered the remaining options: (a) revert doors such that the top part is actually the door, (b) play with nodedef fields and see if other flags may work, or (c) modify the hidden door part to another drawtype that properly prevents this issue. (a) seemed way over the top for now, although it would solve the issue, it would cause a rewrite of most of the code including the old-door-conversion. (b) turned up nothing. (c) turned out to be relatively simple. So, here's the implementation where I turn the hidden door top into a tiny, non-targetable but walkable nodebox that is entirely inside the door hinge. It's entirely transparent, so you still can't see it, can't hit it, nor can you place anything in it or make liquids flow through it. The top part is placed in the right position on placement and not touched further. Falling nodes will properly stop on top of these doors. I've adjusted the door conversion code to properly account for the issue as well, so the only thing remaining is people who have been running a git branch - those can upgrade by re-placing the door.
2016-03-15 05:27:32 +01:00
minetest.remove_node({x = pos.x, y = pos.y + 1, z = pos.z})
Update 'nodeupdate()' to 'check_for_falling()' API
2016-11-22 05:45:31 +01:00
minetest.check_for_falling({x = pos.x, y = pos.y + 1, z = pos.z})
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
end
Revert "Doors: Remove ..." and "Doors: Allow the screwdriver to ..." This reverts commit 5e4a6e8ac68b92c7394b80bb67839b71b4a4a00b, and commit 60cf3f85b6e661482ec2705cadbdc1b04e388d19. The original door API rewrite I posted had all rotation disabled using the correct on_rotate() handler returning `false`. Two subsequent changes attempting first to enable simple rotation and second disabling that again changed the callback handler to a boolean `false`, which is incorrect use in the screwdriver API, and actually allows rotation. The proper way to disable rotation for facedir nodes it to use a full callback handler that does `return false`.
2017-01-15 06:39:17 +01:00
def.on_rotate = function(pos, node, user, mode, new_param2)
return false
end
Add screwdriver callbacks, and code them for doors and beds
2015-05-13 11:49:11 +02:00
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
if def.protected then
Doors: Fix potential crashes, code improvements Fix crash when doors are placed under unknown nodes. Share a can_dig among doors, that does not crash on nil-player. Only set can_dig if we actually protect the door.
2016-07-30 14:21:30 +02:00
def.can_dig = can_dig_door
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
def.on_blast = function() end
Keys: Allow easy sharing of access without commands This code adds the key concept to minetest_game, and integrates it with lockable nodes. Currently supported lockable items are the Steel Door, the Steel Trapdoor, and the Locked Chest. The goal of this modification is to introduce a fine-grained multi- player permission system that is intuitive and usable without any console or chat commands, and doesn't require extra privileges to be granted or setup. Keys can also physically be conveyed to other players, adding to gameplay and adding some personality that is preferable to console commands or editing formspecs. A skeleton key can be crafted with 1 gold ingot. Skeleton keys can then be matched to a lockable node by right-clicking the skeleton key on a lockable node, which changes the skeleton key to a "key". Gold was chosen as it's currently a not-so very useful item, and therefore it's likely that players have some, but aren't really using it for any purpose. This key can subsequently used by any player to open or access that lockable node, including retrieving items from Locked Chests, or putting items in them. They key is programmed to fit only the particular locked node it is programmed to. This is achieved by storing a secret value in both key and locked node. If this secret value doesn't match, the key will not open the locked node. This allows many keys to be created for one chest or door, but a key will only fit one node ever. The secrets are stored in node, and item meta for the key. If a locked node is removed, all keys that opened it are no longer valid. Even if a new door/chest is placed in exactly the same spot, the old keys will no longer fit that node. Keys can be smelted back in gold ingots if they are no longer useful. The method of storing a secret in nodemeta and itemstackmeta is secure as there is no way for the client to create new items on the server with a particular secret metadata value. Even if you could possible create such an itemstack on the client, the server does not ever read itemstackmeta from a client package. The patch adds an API that allows other nodes and nodes added by mods to use the same keys as well. The method how to implement this is described in game_api.txt. The mod should add 2 callbacks to it's node definition. Example code is given. Textures are from PixelBOX, thanks to Gambit.
2015-12-26 20:16:49 +01:00
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)
Change doors to default.can_interact_with_node()
2017-02-21 19:43:34 +01:00
replace_old_owner_information(pos)
Keys: Allow easy sharing of access without commands This code adds the key concept to minetest_game, and integrates it with lockable nodes. Currently supported lockable items are the Steel Door, the Steel Trapdoor, and the Locked Chest. The goal of this modification is to introduce a fine-grained multi- player permission system that is intuitive and usable without any console or chat commands, and doesn't require extra privileges to be granted or setup. Keys can also physically be conveyed to other players, adding to gameplay and adding some personality that is preferable to console commands or editing formspecs. A skeleton key can be crafted with 1 gold ingot. Skeleton keys can then be matched to a lockable node by right-clicking the skeleton key on a lockable node, which changes the skeleton key to a "key". Gold was chosen as it's currently a not-so very useful item, and therefore it's likely that players have some, but aren't really using it for any purpose. This key can subsequently used by any player to open or access that lockable node, including retrieving items from Locked Chests, or putting items in them. They key is programmed to fit only the particular locked node it is programmed to. This is achieved by storing a secret value in both key and locked node. If this secret value doesn't match, the key will not open the locked node. This allows many keys to be created for one chest or door, but a key will only fit one node ever. The secrets are stored in node, and item meta for the key. If a locked node is removed, all keys that opened it are no longer valid. Even if a new door/chest is placed in exactly the same spot, the old keys will no longer fit that node. Keys can be smelted back in gold ingots if they are no longer useful. The method of storing a secret in nodemeta and itemstackmeta is secure as there is no way for the client to create new items on the server with a particular secret metadata value. Even if you could possible create such an itemstack on the client, the server does not ever read itemstackmeta from a client package. The patch adds an API that allows other nodes and nodes added by mods to use the same keys as well. The method how to implement this is described in game_api.txt. The mod should add 2 callbacks to it's node definition. Example code is given. Textures are from PixelBOX, thanks to Gambit.
2015-12-26 20:16:49 +01:00
local meta = minetest.get_meta(pos)
Change doors to default.can_interact_with_node()
2017-02-21 19:43:34 +01:00
local owner = meta:get_string("owner")
Keys: Allow easy sharing of access without commands This code adds the key concept to minetest_game, and integrates it with lockable nodes. Currently supported lockable items are the Steel Door, the Steel Trapdoor, and the Locked Chest. The goal of this modification is to introduce a fine-grained multi- player permission system that is intuitive and usable without any console or chat commands, and doesn't require extra privileges to be granted or setup. Keys can also physically be conveyed to other players, adding to gameplay and adding some personality that is preferable to console commands or editing formspecs. A skeleton key can be crafted with 1 gold ingot. Skeleton keys can then be matched to a lockable node by right-clicking the skeleton key on a lockable node, which changes the skeleton key to a "key". Gold was chosen as it's currently a not-so very useful item, and therefore it's likely that players have some, but aren't really using it for any purpose. This key can subsequently used by any player to open or access that lockable node, including retrieving items from Locked Chests, or putting items in them. They key is programmed to fit only the particular locked node it is programmed to. This is achieved by storing a secret value in both key and locked node. If this secret value doesn't match, the key will not open the locked node. This allows many keys to be created for one chest or door, but a key will only fit one node ever. The secrets are stored in node, and item meta for the key. If a locked node is removed, all keys that opened it are no longer valid. Even if a new door/chest is placed in exactly the same spot, the old keys will no longer fit that node. Keys can be smelted back in gold ingots if they are no longer useful. The method of storing a secret in nodemeta and itemstackmeta is secure as there is no way for the client to create new items on the server with a particular secret metadata value. Even if you could possible create such an itemstack on the client, the server does not ever read itemstackmeta from a client package. The patch adds an API that allows other nodes and nodes added by mods to use the same keys as well. The method how to implement this is described in game_api.txt. The mod should add 2 callbacks to it's node definition. Example code is given. Textures are from PixelBOX, thanks to Gambit.
2015-12-26 20:16:49 +01:00
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
Doors: Disable client dig prediction for protected doors
2017-09-11 21:13:55 +02:00
def.node_dig_prediction = ""
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
else
def.on_blast = function(pos, intensity)
minetest.remove_node(pos)
-- hidden node doesn't get blasted away.
Allow mod namespace for door registrations. This is an adapted version of #861 - by oleastre Most mods had been calling `doors.register_door() with a door name that included the "modname:" prefix, and we should continue to allow mods to do so, without registering the nodenames created in the "doors:" namespace. The default case is to use the "modname:" prefix verbatim. If mods or code calls this function without a prefix, then "doors:" is automatically used. Now that the namespace is corrected, the copy replacement ABM is no longer needed.
2016-02-21 05:03:09 +01:00
minetest.remove_node({x = pos.x, y = pos.y + 1, z = pos.z})
return {name}
Add screwdriver callbacks, and code them for doors and beds
2015-05-13 11:49:11 +02:00
end
end
Clean up door tops if fire destroys bottom. Fixes #909. Door tops are never flammable. This doesn't guard yet against a voxelmanip removing the top node, but that is less of an issue since if a voxelmanip removes the top, then the bottom part remains functional and visibly intact. If the voxelmanip removes the bottom part, but not the top, then this patch makes it clean up the top just fine.
2016-03-12 07:11:39 +01:00
def.on_destruct = function(pos)
minetest.remove_node({x = pos.x, y = pos.y + 1, z = pos.z})
end
Doors: Clean up nodedef usage Allows for more properties to be passed through. Somewhat simplifies the code as well.
2016-03-13 01:12:37 +01:00
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
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
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}}
Doors: Clean up nodedef usage Allows for more properties to be passed through. Somewhat simplifies the code as well.
2016-03-13 01:12:37 +01:00
def.mesh = "door_a.obj"
minetest.register_node(":" .. name .. "_a", def)
def.mesh = "door_b.obj"
minetest.register_node(":" .. name .. "_b", def)
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
Allow mod namespace for door registrations. This is an adapted version of #861 - by oleastre Most mods had been calling `doors.register_door() with a door name that included the "modname:" prefix, and we should continue to allow mods to do so, without registering the nodenames created in the "doors:" namespace. The default case is to use the "modname:" prefix verbatim. If mods or code calls this function without a prefix, then "doors:" is automatically used. Now that the namespace is corrected, the copy replacement ABM is no longer needed.
2016-02-21 05:03:09 +01:00
_doors.registered_doors[name .. "_a"] = true
_doors.registered_doors[name .. "_b"] = true
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
end
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
doors.register("door_wood", {
tiles = {{ name = "doors_door_wood.png", backface_culling = true }},
description = "Wooden Door",
inventory_image = "doors_item_wood.png",
Doors: Make door groups consistent with corresponding materials
2016-07-13 20:24:49 +02:00
groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 2},
Doors: Allow arbitrary recipe to be passed, even nil This allows mod makers to register their own recipies, including none, to register doors.
2016-02-13 19:03:23 +01:00
recipe = {
{"group:wood", "group:wood"},
{"group:wood", "group:wood"},
{"group:wood", "group:wood"},
}
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
})
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
doors.register("door_steel", {
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
tiles = {{name = "doors_door_steel.png", backface_culling = true}},
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
description = "Steel Door",
inventory_image = "doors_item_steel.png",
protected = true,
Doors: Make door groups consistent with corresponding materials
2016-07-13 20:24:49 +02:00
groups = {cracky = 1, level = 2},
Change many metal nodes to use default metal sounds
2016-10-20 01:34:22 +02:00
sounds = default.node_sound_metal_defaults(),
Add steel door/trapdoor sounds. I've found a favorable steel door sound from a parking garage door that isn't abrupt or scary, just sounds like a nice solid metal door. The sample had both opening and closing sounds, and so they match nicely. Amplified and mixed several samples together to reduce ambient noise, and get the right level compared to wood doors. Attribution was added as well. CC-BY-3.0 sounds.
2016-03-06 08:08:02 +01:00
sound_open = "doors_steel_door_open",
sound_close = "doors_steel_door_close",
Doors: Allow arbitrary recipe to be passed, even nil This allows mod makers to register their own recipies, including none, to register doors.
2016-02-13 19:03:23 +01:00
recipe = {
{"default:steel_ingot", "default:steel_ingot"},
{"default:steel_ingot", "default:steel_ingot"},
{"default:steel_ingot", "default:steel_ingot"},
}
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
})
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
doors.register("door_glass", {
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
tiles = {"doors_door_glass.png"},
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
description = "Glass Door",
inventory_image = "doors_item_glass.png",
Doors: Make door groups consistent with corresponding materials
2016-07-13 20:24:49 +02:00
groups = {cracky=3, oddly_breakable_by_hand=3},
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
sounds = default.node_sound_glass_defaults(),
Doors: Add dedicated sounds for glass doors Changed node sounds for steel door/trapdoor to stone defaults instead of wood defaults
2016-06-23 04:06:57 +02:00
sound_open = "doors_glass_door_open",
sound_close = "doors_glass_door_close",
Doors: Allow arbitrary recipe to be passed, even nil This allows mod makers to register their own recipies, including none, to register doors.
2016-02-13 19:03:23 +01:00
recipe = {
{"default:glass", "default:glass"},
{"default:glass", "default:glass"},
{"default:glass", "default:glass"},
}
Move all common mods back to minetest_game
2013-05-18 16:05:16 +02:00
})
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
doors.register("door_obsidian_glass", {
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
tiles = {"doors_door_obsidian_glass.png"},
Rename Glass Door (the obisian one) to Obsidian Glass Door
2016-03-22 08:26:36 +01:00
description = "Obsidian Glass Door",
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
inventory_image = "doors_item_obsidian_glass.png",
Doors: Make door groups consistent with corresponding materials
2016-07-13 20:24:49 +02:00
groups = {cracky=3},
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
sounds = default.node_sound_glass_defaults(),
Doors: Add dedicated sounds for glass doors Changed node sounds for steel door/trapdoor to stone defaults instead of wood defaults
2016-06-23 04:06:57 +02:00
sound_open = "doors_glass_door_open",
sound_close = "doors_glass_door_close",
Doors: Allow arbitrary recipe to be passed, even nil This allows mod makers to register their own recipies, including none, to register doors.
2016-02-13 19:03:23 +01:00
recipe = {
{"default:obsidian_glass", "default:obsidian_glass"},
{"default:obsidian_glass", "default:obsidian_glass"},
{"default:obsidian_glass", "default:obsidian_glass"},
},
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
})
Fallback doors.register_door() code. This function maps doors.register_door to the new API as far as reasonable. We can't map the texture, so we fall back to a default texture. An error message is printed if mod writers did not provide the needed new tiles field for the door. The created doors are functional and a full replacement. Old doors are replaced with the new ones through an ABM.
2016-02-20 08:32:43 +01:00
-- 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
Allow mod namespace for door registrations. This is an adapted version of #861 - by oleastre Most mods had been calling `doors.register_door() with a door name that included the "modname:" prefix, and we should continue to allow mods to do so, without registering the nodenames created in the "doors:" namespace. The default case is to use the "modname:" prefix verbatim. If mods or code calls this function without a prefix, then "doors:" is automatically used. Now that the namespace is corrected, the copy replacement ABM is no longer needed.
2016-02-21 05:03:09 +01:00
doors.register(name, def)
Fallback doors.register_door() code. This function maps doors.register_door to the new API as far as reasonable. We can't map the texture, so we fall back to a default texture. An error message is printed if mod writers did not provide the needed new tiles field for the door. The created doors are functional and a full replacement. Old doors are replaced with the new ones through an ABM.
2016-02-20 08:32:43 +01:00
end
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
----trapdoor----
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
Doors: Remove unnecessary node lookups
2016-07-02 02:30:45 +02:00
function _doors.trapdoor_toggle(pos, node, clicker)
Doors: Fix missing node parameter passing
2016-07-11 17:50:19 +02:00
node = node or minetest.get_node(pos)
Keys: Show owner in description Utilizes several new features allowing the description of an item to be changed using the `description` meta key. This also moves keys from using the old single-value itemstack metadata system to the new node-like metadata system.
2017-02-26 18:24:12 +01:00
Change doors to default.can_interact_with_node()
2017-02-21 19:43:34 +01:00
replace_old_owner_information(pos)
Keys: Allow easy sharing of access without commands This code adds the key concept to minetest_game, and integrates it with lockable nodes. Currently supported lockable items are the Steel Door, the Steel Trapdoor, and the Locked Chest. The goal of this modification is to introduce a fine-grained multi- player permission system that is intuitive and usable without any console or chat commands, and doesn't require extra privileges to be granted or setup. Keys can also physically be conveyed to other players, adding to gameplay and adding some personality that is preferable to console commands or editing formspecs. A skeleton key can be crafted with 1 gold ingot. Skeleton keys can then be matched to a lockable node by right-clicking the skeleton key on a lockable node, which changes the skeleton key to a "key". Gold was chosen as it's currently a not-so very useful item, and therefore it's likely that players have some, but aren't really using it for any purpose. This key can subsequently used by any player to open or access that lockable node, including retrieving items from Locked Chests, or putting items in them. They key is programmed to fit only the particular locked node it is programmed to. This is achieved by storing a secret value in both key and locked node. If this secret value doesn't match, the key will not open the locked node. This allows many keys to be created for one chest or door, but a key will only fit one node ever. The secrets are stored in node, and item meta for the key. If a locked node is removed, all keys that opened it are no longer valid. Even if a new door/chest is placed in exactly the same spot, the old keys will no longer fit that node. Keys can be smelted back in gold ingots if they are no longer useful. The method of storing a secret in nodemeta and itemstackmeta is secure as there is no way for the client to create new items on the server with a particular secret metadata value. Even if you could possible create such an itemstack on the client, the server does not ever read itemstackmeta from a client package. The patch adds an API that allows other nodes and nodes added by mods to use the same keys as well. The method how to implement this is described in game_api.txt. The mod should add 2 callbacks to it's node definition. Example code is given. Textures are from PixelBOX, thanks to Gambit.
2015-12-26 20:16:49 +01:00
Doors: Ignore permission check if player parameter is omitted As written in game_api.txt.
2017-04-17 12:56:27 +02:00
if clicker and not default.can_interact_with_node(clicker, pos) then
Change doors to default.can_interact_with_node()
2017-02-21 19:43:34 +01:00
return false
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
end
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
local def = minetest.registered_nodes[node.name]
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
if string.sub(node.name, -5) == "_open" then
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
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})
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
else
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
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})
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
end
end
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
Clean up trapdoors code and make them more flexible, so custom trapdoors can be registered by other mods
2015-02-03 20:11:23 +01:00
function doors.register_trapdoor(name, def)
Doors: Same naming for trapdoors as for doors This makes register_trapdoor act the same as the register_door. If `name` isn't prefixed, it will be prefixed with "doors:".
2016-07-17 18:52:42 +02:00
if not name:find(":") then
name = "doors:" .. name
end
Fix whitespace errors to silence luacheck. Currently all minetest_game PR's are failing travis since the upstream luacheck now also warns about whitespace issues, and there are a few of those in the code. This fixes all of them so we can yet again rely on luacheck.
2016-11-20 04:24:37 +01:00
Clean up trapdoors code and make them more flexible, so custom trapdoors can be registered by other mods
2015-02-03 20:11:23 +01:00
local name_closed = name
local name_opened = name.."_open"
Always return the leftover ItemStack for on_place and on_rightclick
2016-07-01 22:43:02 +02:00
def.on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
Doors: Remove unnecessary node lookups
2016-07-02 02:30:45 +02:00
_doors.trapdoor_toggle(pos, node, clicker)
Always return the leftover ItemStack for on_place and on_rightclick
2016-07-01 22:43:02 +02:00
return itemstack
Fix some undeclared global variables
2014-11-25 21:34:40 +01:00
end
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
Clean up trapdoors code and make them more flexible, so custom trapdoors can be registered by other mods
2015-02-03 20:11:23 +01:00
-- Common trapdoor configuration
def.drawtype = "nodebox"
def.paramtype = "light"
def.paramtype2 = "facedir"
Fix is_ground_content settings for nodes Remove line if set to the default of 'true'
2015-06-14 05:58:54 +02:00
def.is_ground_content = false
Steel Trapdoor. Adds a steel trapdoor. Textures were painted from scratch, and inspired by the current Steel Door. Ownership on the trapdoor works as expected, and so does the crafting recipe.
2015-12-15 08:35:14 +01:00
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
if def.protected then
Doors: Fix potential crashes, code improvements Fix crash when doors are placed under unknown nodes. Share a can_dig among doors, that does not crash on nil-player. Only set can_dig if we actually protect the door.
2016-07-30 14:21:30 +02:00
def.can_dig = can_dig_door
Steel Trapdoor. Adds a steel trapdoor. Textures were painted from scratch, and inspired by the current Steel Door. Ownership on the trapdoor works as expected, and so does the crafting recipe.
2015-12-15 08:35:14 +01:00
def.after_place_node = function(pos, placer, itemstack, pointed_thing)
local pn = placer:get_player_name()
local meta = minetest.get_meta(pos)
Change doors to default.can_interact_with_node()
2017-02-21 19:43:34 +01:00
meta:set_string("owner", pn)
Steel Trapdoor. Adds a steel trapdoor. Textures were painted from scratch, and inspired by the current Steel Door. Ownership on the trapdoor works as expected, and so does the crafting recipe.
2015-12-15 08:35:14 +01:00
meta:set_string("infotext", "Owned by "..pn)
Use creative.is_enabled_for for creative mode if possible (#1558)
2017-03-29 21:02:26 +02:00
return (creative and creative.is_enabled_for and creative.is_enabled_for(pn))
Steel Trapdoor. Adds a steel trapdoor. Textures were painted from scratch, and inspired by the current Steel Door. Ownership on the trapdoor works as expected, and so does the crafting recipe.
2015-12-15 08:35:14 +01:00
end
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
def.on_blast = function() end
Keys: Allow easy sharing of access without commands This code adds the key concept to minetest_game, and integrates it with lockable nodes. Currently supported lockable items are the Steel Door, the Steel Trapdoor, and the Locked Chest. The goal of this modification is to introduce a fine-grained multi- player permission system that is intuitive and usable without any console or chat commands, and doesn't require extra privileges to be granted or setup. Keys can also physically be conveyed to other players, adding to gameplay and adding some personality that is preferable to console commands or editing formspecs. A skeleton key can be crafted with 1 gold ingot. Skeleton keys can then be matched to a lockable node by right-clicking the skeleton key on a lockable node, which changes the skeleton key to a "key". Gold was chosen as it's currently a not-so very useful item, and therefore it's likely that players have some, but aren't really using it for any purpose. This key can subsequently used by any player to open or access that lockable node, including retrieving items from Locked Chests, or putting items in them. They key is programmed to fit only the particular locked node it is programmed to. This is achieved by storing a secret value in both key and locked node. If this secret value doesn't match, the key will not open the locked node. This allows many keys to be created for one chest or door, but a key will only fit one node ever. The secrets are stored in node, and item meta for the key. If a locked node is removed, all keys that opened it are no longer valid. Even if a new door/chest is placed in exactly the same spot, the old keys will no longer fit that node. Keys can be smelted back in gold ingots if they are no longer useful. The method of storing a secret in nodemeta and itemstackmeta is secure as there is no way for the client to create new items on the server with a particular secret metadata value. Even if you could possible create such an itemstack on the client, the server does not ever read itemstackmeta from a client package. The patch adds an API that allows other nodes and nodes added by mods to use the same keys as well. The method how to implement this is described in game_api.txt. The mod should add 2 callbacks to it's node definition. Example code is given. Textures are from PixelBOX, thanks to Gambit.
2015-12-26 20:16:49 +01:00
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)
Change doors to default.can_interact_with_node()
2017-02-21 19:43:34 +01:00
replace_old_owner_information(pos)
Keys: Allow easy sharing of access without commands This code adds the key concept to minetest_game, and integrates it with lockable nodes. Currently supported lockable items are the Steel Door, the Steel Trapdoor, and the Locked Chest. The goal of this modification is to introduce a fine-grained multi- player permission system that is intuitive and usable without any console or chat commands, and doesn't require extra privileges to be granted or setup. Keys can also physically be conveyed to other players, adding to gameplay and adding some personality that is preferable to console commands or editing formspecs. A skeleton key can be crafted with 1 gold ingot. Skeleton keys can then be matched to a lockable node by right-clicking the skeleton key on a lockable node, which changes the skeleton key to a "key". Gold was chosen as it's currently a not-so very useful item, and therefore it's likely that players have some, but aren't really using it for any purpose. This key can subsequently used by any player to open or access that lockable node, including retrieving items from Locked Chests, or putting items in them. They key is programmed to fit only the particular locked node it is programmed to. This is achieved by storing a secret value in both key and locked node. If this secret value doesn't match, the key will not open the locked node. This allows many keys to be created for one chest or door, but a key will only fit one node ever. The secrets are stored in node, and item meta for the key. If a locked node is removed, all keys that opened it are no longer valid. Even if a new door/chest is placed in exactly the same spot, the old keys will no longer fit that node. Keys can be smelted back in gold ingots if they are no longer useful. The method of storing a secret in nodemeta and itemstackmeta is secure as there is no way for the client to create new items on the server with a particular secret metadata value. Even if you could possible create such an itemstack on the client, the server does not ever read itemstackmeta from a client package. The patch adds an API that allows other nodes and nodes added by mods to use the same keys as well. The method how to implement this is described in game_api.txt. The mod should add 2 callbacks to it's node definition. Example code is given. Textures are from PixelBOX, thanks to Gambit.
2015-12-26 20:16:49 +01:00
local meta = minetest.get_meta(pos)
Change doors to default.can_interact_with_node()
2017-02-21 19:43:34 +01:00
local owner = meta:get_string("owner")
Keys: Allow easy sharing of access without commands This code adds the key concept to minetest_game, and integrates it with lockable nodes. Currently supported lockable items are the Steel Door, the Steel Trapdoor, and the Locked Chest. The goal of this modification is to introduce a fine-grained multi- player permission system that is intuitive and usable without any console or chat commands, and doesn't require extra privileges to be granted or setup. Keys can also physically be conveyed to other players, adding to gameplay and adding some personality that is preferable to console commands or editing formspecs. A skeleton key can be crafted with 1 gold ingot. Skeleton keys can then be matched to a lockable node by right-clicking the skeleton key on a lockable node, which changes the skeleton key to a "key". Gold was chosen as it's currently a not-so very useful item, and therefore it's likely that players have some, but aren't really using it for any purpose. This key can subsequently used by any player to open or access that lockable node, including retrieving items from Locked Chests, or putting items in them. They key is programmed to fit only the particular locked node it is programmed to. This is achieved by storing a secret value in both key and locked node. If this secret value doesn't match, the key will not open the locked node. This allows many keys to be created for one chest or door, but a key will only fit one node ever. The secrets are stored in node, and item meta for the key. If a locked node is removed, all keys that opened it are no longer valid. Even if a new door/chest is placed in exactly the same spot, the old keys will no longer fit that node. Keys can be smelted back in gold ingots if they are no longer useful. The method of storing a secret in nodemeta and itemstackmeta is secure as there is no way for the client to create new items on the server with a particular secret metadata value. Even if you could possible create such an itemstack on the client, the server does not ever read itemstackmeta from a client package. The patch adds an API that allows other nodes and nodes added by mods to use the same keys as well. The method how to implement this is described in game_api.txt. The mod should add 2 callbacks to it's node definition. Example code is given. Textures are from PixelBOX, thanks to Gambit.
2015-12-26 20:16:49 +01:00
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
Doors: Same prediction change for trapdoors Forgot this in the last commit, thanks @Fixer-007
2017-09-11 22:52:19 +02:00
def.node_dig_prediction = ""
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
else
def.on_blast = function(pos, intensity)
minetest.remove_node(pos)
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
return {name}
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
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"
Steel Trapdoor. Adds a steel trapdoor. Textures were painted from scratch, and inspired by the current Steel Door. Ownership on the trapdoor works as expected, and so does the crafting recipe.
2015-12-15 08:35:14 +01:00
end
Clean up trapdoors code and make them more flexible, so custom trapdoors can be registered by other mods
2015-02-03 20:11:23 +01:00
local def_opened = table.copy(def)
local def_closed = table.copy(def)
def_closed.node_box = {
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
type = "fixed",
Better trapdoor side appearance. We're using a normal wooden side texture to draw the sides of trapdoors. But the side textures have only 2 edges that have a nice texture for the 2px wide trapdoor. We can either repaint the textures, or just rotate the texture properly for the two sides that need it. Because the side texture for wooden doors was just a default:wood texture, it clashes with the colors in the trapdoor, and so we add a wooden trapdoor-matching tile side texture as well. This also improves the steel trapdoor side, but without a texture change there since that was already a specially drawn texture for that node. We also increase the thickness of the trapdoor to 2px. Right now the model is 0.4 large, but this causes the side textures to look odd as there's a mismatch in pixel size. By scaling the trapdoor side up to exactly 2px, the sides look natural. Thanks to @kilbith for the suggestion.
2016-01-16 23:53:27 +01:00
fixed = {-0.5, -0.5, -0.5, 0.5, -6/16, 0.5}
Clean up trapdoors code and make them more flexible, so custom trapdoors can be registered by other mods
2015-02-03 20:11:23 +01:00
}
def_closed.selection_box = {
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
type = "fixed",
Better trapdoor side appearance. We're using a normal wooden side texture to draw the sides of trapdoors. But the side textures have only 2 edges that have a nice texture for the 2px wide trapdoor. We can either repaint the textures, or just rotate the texture properly for the two sides that need it. Because the side texture for wooden doors was just a default:wood texture, it clashes with the colors in the trapdoor, and so we add a wooden trapdoor-matching tile side texture as well. This also improves the steel trapdoor side, but without a texture change there since that was already a specially drawn texture for that node. We also increase the thickness of the trapdoor to 2px. Right now the model is 0.4 large, but this causes the side textures to look odd as there's a mismatch in pixel size. By scaling the trapdoor side up to exactly 2px, the sides look natural. Thanks to @kilbith for the suggestion.
2016-01-16 23:53:27 +01:00
fixed = {-0.5, -0.5, -0.5, 0.5, -6/16, 0.5}
Clean up trapdoors code and make them more flexible, so custom trapdoors can be registered by other mods
2015-02-03 20:11:23 +01:00
}
Doors: Fix orientations of trapdoor textures
2016-07-18 07:14:01 +02:00
def_closed.tiles = {def.tile_front,
def.tile_front .. '^[transformFY',
def.tile_side, def.tile_side,
def.tile_side, def.tile_side}
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
Clean up trapdoors code and make them more flexible, so custom trapdoors can be registered by other mods
2015-02-03 20:11:23 +01:00
def_opened.node_box = {
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
type = "fixed",
Better trapdoor side appearance. We're using a normal wooden side texture to draw the sides of trapdoors. But the side textures have only 2 edges that have a nice texture for the 2px wide trapdoor. We can either repaint the textures, or just rotate the texture properly for the two sides that need it. Because the side texture for wooden doors was just a default:wood texture, it clashes with the colors in the trapdoor, and so we add a wooden trapdoor-matching tile side texture as well. This also improves the steel trapdoor side, but without a texture change there since that was already a specially drawn texture for that node. We also increase the thickness of the trapdoor to 2px. Right now the model is 0.4 large, but this causes the side textures to look odd as there's a mismatch in pixel size. By scaling the trapdoor side up to exactly 2px, the sides look natural. Thanks to @kilbith for the suggestion.
2016-01-16 23:53:27 +01:00
fixed = {-0.5, -0.5, 6/16, 0.5, 0.5, 0.5}
Clean up trapdoors code and make them more flexible, so custom trapdoors can be registered by other mods
2015-02-03 20:11:23 +01:00
}
def_opened.selection_box = {
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
type = "fixed",
Better trapdoor side appearance. We're using a normal wooden side texture to draw the sides of trapdoors. But the side textures have only 2 edges that have a nice texture for the 2px wide trapdoor. We can either repaint the textures, or just rotate the texture properly for the two sides that need it. Because the side texture for wooden doors was just a default:wood texture, it clashes with the colors in the trapdoor, and so we add a wooden trapdoor-matching tile side texture as well. This also improves the steel trapdoor side, but without a texture change there since that was already a specially drawn texture for that node. We also increase the thickness of the trapdoor to 2px. Right now the model is 0.4 large, but this causes the side textures to look odd as there's a mismatch in pixel size. By scaling the trapdoor side up to exactly 2px, the sides look natural. Thanks to @kilbith for the suggestion.
2016-01-16 23:53:27 +01:00
fixed = {-0.5, -0.5, 6/16, 0.5, 0.5, 0.5}
Clean up trapdoors code and make them more flexible, so custom trapdoors can be registered by other mods
2015-02-03 20:11:23 +01:00
}
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
def_opened.tiles = {def.tile_side, def.tile_side,
Better trapdoor side appearance. We're using a normal wooden side texture to draw the sides of trapdoors. But the side textures have only 2 edges that have a nice texture for the 2px wide trapdoor. We can either repaint the textures, or just rotate the texture properly for the two sides that need it. Because the side texture for wooden doors was just a default:wood texture, it clashes with the colors in the trapdoor, and so we add a wooden trapdoor-matching tile side texture as well. This also improves the steel trapdoor side, but without a texture change there since that was already a specially drawn texture for that node. We also increase the thickness of the trapdoor to 2px. Right now the model is 0.4 large, but this causes the side textures to look odd as there's a mismatch in pixel size. By scaling the trapdoor side up to exactly 2px, the sides look natural. Thanks to @kilbith for the suggestion.
2016-01-16 23:53:27 +01:00
def.tile_side .. '^[transform3',
def.tile_side .. '^[transform1',
Doors: Fix orientations of trapdoor textures
2016-07-18 07:14:01 +02:00
def.tile_front .. '^[transform46',
def.tile_front .. '^[transform6'}
Better trapdoor side appearance. We're using a normal wooden side texture to draw the sides of trapdoors. But the side textures have only 2 edges that have a nice texture for the 2px wide trapdoor. We can either repaint the textures, or just rotate the texture properly for the two sides that need it. Because the side texture for wooden doors was just a default:wood texture, it clashes with the colors in the trapdoor, and so we add a wooden trapdoor-matching tile side texture as well. This also improves the steel trapdoor side, but without a texture change there since that was already a specially drawn texture for that node. We also increase the thickness of the trapdoor to 2px. Right now the model is 0.4 large, but this causes the side textures to look odd as there's a mismatch in pixel size. By scaling the trapdoor side up to exactly 2px, the sides look natural. Thanks to @kilbith for the suggestion.
2016-01-16 23:53:27 +01:00
Clean up trapdoors code and make them more flexible, so custom trapdoors can be registered by other mods
2015-02-03 20:11:23 +01:00
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)
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
_doors.registered_trapdoors[name_opened] = true
_doors.registered_trapdoors[name_closed] = true
end
Clean up trapdoors code and make them more flexible, so custom trapdoors can be registered by other mods
2015-02-03 20:11:23 +01:00
doors.register_trapdoor("doors:trapdoor", {
Improve node descriptions (#1834)
2017-07-23 10:26:10 +02:00
description = "Wooden Trapdoor",
Clean up trapdoors code and make them more flexible, so custom trapdoors can be registered by other mods
2015-02-03 20:11:23 +01:00
inventory_image = "doors_trapdoor.png",
wield_image = "doors_trapdoor.png",
tile_front = "doors_trapdoor.png",
tile_side = "doors_trapdoor_side.png",
Doors: Make door groups consistent with corresponding materials
2016-07-13 20:24:49 +02:00
groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 2, door = 1},
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
})
Steel Trapdoor. Adds a steel trapdoor. Textures were painted from scratch, and inspired by the current Steel Door. Ownership on the trapdoor works as expected, and so does the crafting recipe.
2015-12-15 08:35:14 +01:00
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",
New mesh door models, and extensive door API This patch replaces the default door nodes with a new mesh model and nodes. Two new models were added that are 2 blocks high. One for left-hinge and one for right-hinge doors. This allows us to make a single texture fit on both models. The alternative would have been 1 model and 2 unmapped textures, which is more work for mod developers. Doors work exactly like the old doors, including ownership, breaking doors, opening and closing. Under the hood, we can prevent the top part of the door from being obstructed by placing an invisible node. This prevents liquids from flowing through doors or people placing sand or other blocks in the top half. The door code automatically places and removes these as needed. Metadata is used to store door state, just like the old version. A doors API is added, it allows mods to use the API to open/close or toggle door states without worrying about sounds, permissions and other details. This is intended for e.g. mesecons. This API allows mods to manipulate or inspect doors for players or for themselves. In-game old door nodes are automatically converted using an ABM and preserve ownership and orientation and state. TNT blows up all doors and trapdoors except for the steel ones, who can survive a blast. We return an itemstack in on_blast(), which requires a TNT API patch which is also pending. We enable backface culling for most of these doors, as this gives the identical visual appearance that the old doors had. In the case of the glass door, there's a slight twist. The texture files used by the new doors have new names that do not conflict with previous texture file names to avoid texture pack conflicts. Thanks to red-001 <red-001@users.noreply.github.com> for some of the conversion code, cleanups, and extra textures.
2016-01-16 03:50:32 +01:00
protected = true,
Change many metal nodes to use default metal sounds
2016-10-20 01:34:22 +02:00
sounds = default.node_sound_metal_defaults(),
Add steel door/trapdoor sounds. I've found a favorable steel door sound from a parking garage door that isn't abrupt or scary, just sounds like a nice solid metal door. The sample had both opening and closing sounds, and so they match nicely. Amplified and mixed several samples together to reduce ambient noise, and get the right level compared to wood doors. Attribution was added as well. CC-BY-3.0 sounds.
2016-03-06 08:08:02 +01:00
sound_open = "doors_steel_door_open",
sound_close = "doors_steel_door_close",
Doors: Make door groups consistent with corresponding materials
2016-07-13 20:24:49 +02:00
groups = {cracky = 1, level = 2, door = 1},
Steel Trapdoor. Adds a steel trapdoor. Textures were painted from scratch, and inspired by the current Steel Door. Ownership on the trapdoor works as expected, and so does the crafting recipe.
2015-12-15 08:35:14 +01:00
})
Added Glass and Obsidian Glass door (doors mod)
2014-04-16 16:31:30 +02:00
minetest.register_craft({
output = 'doors:trapdoor 2',
recipe = {
{'group:wood', 'group:wood', 'group:wood'},
{'group:wood', 'group:wood', 'group:wood'},
{'', '', ''},
}
})
Steel Trapdoor. Adds a steel trapdoor. Textures were painted from scratch, and inspired by the current Steel Door. Ownership on the trapdoor works as expected, and so does the crafting recipe.
2015-12-15 08:35:14 +01:00
minetest.register_craft({
Fix trapdoor recipe conflict with iron bar recipe. In oversight, I added this recipe not verifying that it was already taken. We change this to a 2x2 iron bar recipe. The shape and amount are reasonable (reduced to output 1 steel trapdoor), and I verified that it wasn't in use. Fixes #779
2016-01-11 21:39:24 +01:00
output = 'doors:trapdoor_steel',
Steel Trapdoor. Adds a steel trapdoor. Textures were painted from scratch, and inspired by the current Steel Door. Ownership on the trapdoor works as expected, and so does the crafting recipe.
2015-12-15 08:35:14 +01:00
recipe = {
Fix trapdoor recipe conflict with iron bar recipe. In oversight, I added this recipe not verifying that it was already taken. We change this to a 2x2 iron bar recipe. The shape and amount are reasonable (reduced to output 1 steel trapdoor), and I verified that it wasn't in use. Fixes #779
2016-01-11 21:39:24 +01:00
{'default:steel_ingot', 'default:steel_ingot'},
{'default:steel_ingot', 'default:steel_ingot'},
Steel Trapdoor. Adds a steel trapdoor. Textures were painted from scratch, and inspired by the current Steel Door. Ownership on the trapdoor works as expected, and so does the crafting recipe.
2015-12-15 08:35:14 +01:00
}
})
Add a simple, but stylish fence gate. This fence gate builds on NDT_CONNECTED by assuming fence nodes will automatically connect to it's sides properly. The fence gate will open and close just like doors, with sounds, but it only opens one way. The gate sticks out quite a bit and can be bumped into, so the fence may be used as some sort of path switch. The fence gate offers no form of protection and can be opened and closed by anyone. This is done on purpose - the fencegate isn't meant to provide protection from players, as fences can be trivially jumped over. Instead, these fences should be used for protecting crops from hungry sheep, or keeping rabbits in their pen, or just decoration. Mods can also modify the mod to add protection, of course. A recipe is added to make these. It's 4 sticks and 2 wood (any) as follows: stick wood stick stick wood stick The collision box of the open gate is such that if two gates are connected but mirrored (making an M shape) then you can walk a large entity that's larger than 1.0 wide through the opening. The gate of an opened fence can also be stood upon or bumped into. I've mixed together some sounds to provide a somewhat light sound experience, one that one would expect from a small gate latching open and close. This change requires #873, otherwise it doesn't connect to fences.
2016-02-26 16:30:38 +01:00
----fence gate----
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
function doors.register_fencegate(name, def)
local fence = {
description = def.description,
drawtype = "mesh",
Add backface_culling to open chests and fencegates
2017-06-19 18:51:21 +02:00
tiles = {},
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
paramtype = "light",
paramtype2 = "facedir",
sunlight_propagates = true,
is_ground_content = false,
drop = name .. "_closed",
Doors: Code cleanup Remove spaces inside curly brackets Split lines over 90 columns
2016-07-07 18:48:02 +02:00
connect_sides = {"left", "right"},
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
groups = def.groups,
sounds = def.sounds,
Always return the leftover ItemStack for on_place and on_rightclick
2016-07-01 22:43:02 +02:00
on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
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})
Always return the leftover ItemStack for on_place and on_rightclick
2016-07-01 22:43:02 +02:00
return itemstack
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
end,
selection_box = {
type = "fixed",
fixed = {-1/2, -1/2, -1/4, 1/2, 1/2, 1/4},
},
}
Add backface_culling to open chests and fencegates
2017-06-19 18:51:21 +02:00
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
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
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 = {
Add a simple, but stylish fence gate. This fence gate builds on NDT_CONNECTED by assuming fence nodes will automatically connect to it's sides properly. The fence gate will open and close just like doors, with sounds, but it only opens one way. The gate sticks out quite a bit and can be bumped into, so the fence may be used as some sort of path switch. The fence gate offers no form of protection and can be opened and closed by anyone. This is done on purpose - the fencegate isn't meant to provide protection from players, as fences can be trivially jumped over. Instead, these fences should be used for protecting crops from hungry sheep, or keeping rabbits in their pen, or just decoration. Mods can also modify the mod to add protection, of course. A recipe is added to make these. It's 4 sticks and 2 wood (any) as follows: stick wood stick stick wood stick The collision box of the open gate is such that if two gates are connected but mirrored (making an M shape) then you can walk a large entity that's larger than 1.0 wide through the opening. The gate of an opened fence can also be stood upon or bumped into. I've mixed together some sounds to provide a somewhat light sound experience, one that one would expect from a small gate latching open and close. This change requires #873, otherwise it doesn't connect to fences.
2016-02-26 16:30:38 +01:00
type = "fixed",
fixed = {-1/2, -1/2, -1/4, 1/2, 1/2, 1/4},
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
}
Add a simple, but stylish fence gate. This fence gate builds on NDT_CONNECTED by assuming fence nodes will automatically connect to it's sides properly. The fence gate will open and close just like doors, with sounds, but it only opens one way. The gate sticks out quite a bit and can be bumped into, so the fence may be used as some sort of path switch. The fence gate offers no form of protection and can be opened and closed by anyone. This is done on purpose - the fencegate isn't meant to provide protection from players, as fences can be trivially jumped over. Instead, these fences should be used for protecting crops from hungry sheep, or keeping rabbits in their pen, or just decoration. Mods can also modify the mod to add protection, of course. A recipe is added to make these. It's 4 sticks and 2 wood (any) as follows: stick wood stick stick wood stick The collision box of the open gate is such that if two gates are connected but mirrored (making an M shape) then you can walk a large entity that's larger than 1.0 wide through the opening. The gate of an opened fence can also be stood upon or bumped into. I've mixed together some sounds to provide a somewhat light sound experience, one that one would expect from a small gate latching open and close. This change requires #873, otherwise it doesn't connect to fences.
2016-02-26 16:30:38 +01:00
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
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},
Doors: Trim open fencegate collison box again The collision box still extended into a neighbouring empty node, causing falling node objects to collide but not transform back into normal nodes. Completes the fix started in a previous similar commit.
2016-09-22 14:46:12 +02:00
{-1/2, -3/8, -1/2, -3/8, 3/8, 0}},
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
}
Add a simple, but stylish fence gate. This fence gate builds on NDT_CONNECTED by assuming fence nodes will automatically connect to it's sides properly. The fence gate will open and close just like doors, with sounds, but it only opens one way. The gate sticks out quite a bit and can be bumped into, so the fence may be used as some sort of path switch. The fence gate offers no form of protection and can be opened and closed by anyone. This is done on purpose - the fencegate isn't meant to provide protection from players, as fences can be trivially jumped over. Instead, these fences should be used for protecting crops from hungry sheep, or keeping rabbits in their pen, or just decoration. Mods can also modify the mod to add protection, of course. A recipe is added to make these. It's 4 sticks and 2 wood (any) as follows: stick wood stick stick wood stick The collision box of the open gate is such that if two gates are connected but mirrored (making an M shape) then you can walk a large entity that's larger than 1.0 wide through the opening. The gate of an opened fence can also be stood upon or bumped into. I've mixed together some sounds to provide a somewhat light sound experience, one that one would expect from a small gate latching open and close. This change requires #873, otherwise it doesn't connect to fences.
2016-02-26 16:30:38 +01:00
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
minetest.register_node(":" .. name .. "_closed", fence_closed)
minetest.register_node(":" .. name .. "_open", fence_open)
Add a simple, but stylish fence gate. This fence gate builds on NDT_CONNECTED by assuming fence nodes will automatically connect to it's sides properly. The fence gate will open and close just like doors, with sounds, but it only opens one way. The gate sticks out quite a bit and can be bumped into, so the fence may be used as some sort of path switch. The fence gate offers no form of protection and can be opened and closed by anyone. This is done on purpose - the fencegate isn't meant to provide protection from players, as fences can be trivially jumped over. Instead, these fences should be used for protecting crops from hungry sheep, or keeping rabbits in their pen, or just decoration. Mods can also modify the mod to add protection, of course. A recipe is added to make these. It's 4 sticks and 2 wood (any) as follows: stick wood stick stick wood stick The collision box of the open gate is such that if two gates are connected but mirrored (making an M shape) then you can walk a large entity that's larger than 1.0 wide through the opening. The gate of an opened fence can also be stood upon or bumped into. I've mixed together some sounds to provide a somewhat light sound experience, one that one would expect from a small gate latching open and close. This change requires #873, otherwise it doesn't connect to fences.
2016-02-26 16:30:38 +01:00
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
minetest.register_craft({
output = name .. "_closed",
recipe = {
{"default:stick", def.material, "default:stick"},
{"default:stick", def.material, "default:stick"}
}
})
end
Add a simple, but stylish fence gate. This fence gate builds on NDT_CONNECTED by assuming fence nodes will automatically connect to it's sides properly. The fence gate will open and close just like doors, with sounds, but it only opens one way. The gate sticks out quite a bit and can be bumped into, so the fence may be used as some sort of path switch. The fence gate offers no form of protection and can be opened and closed by anyone. This is done on purpose - the fencegate isn't meant to provide protection from players, as fences can be trivially jumped over. Instead, these fences should be used for protecting crops from hungry sheep, or keeping rabbits in their pen, or just decoration. Mods can also modify the mod to add protection, of course. A recipe is added to make these. It's 4 sticks and 2 wood (any) as follows: stick wood stick stick wood stick The collision box of the open gate is such that if two gates are connected but mirrored (making an M shape) then you can walk a large entity that's larger than 1.0 wide through the opening. The gate of an opened fence can also be stood upon or bumped into. I've mixed together some sounds to provide a somewhat light sound experience, one that one would expect from a small gate latching open and close. This change requires #873, otherwise it doesn't connect to fences.
2016-02-26 16:30:38 +01:00
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
doors.register_fencegate("doors:gate_wood", {
Improve node descriptions (#1834)
2017-07-23 10:26:10 +02:00
description = "Apple Wood Fence Gate",
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
texture = "default_wood.png",
material = "default:wood",
groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 2}
Add a simple, but stylish fence gate. This fence gate builds on NDT_CONNECTED by assuming fence nodes will automatically connect to it's sides properly. The fence gate will open and close just like doors, with sounds, but it only opens one way. The gate sticks out quite a bit and can be bumped into, so the fence may be used as some sort of path switch. The fence gate offers no form of protection and can be opened and closed by anyone. This is done on purpose - the fencegate isn't meant to provide protection from players, as fences can be trivially jumped over. Instead, these fences should be used for protecting crops from hungry sheep, or keeping rabbits in their pen, or just decoration. Mods can also modify the mod to add protection, of course. A recipe is added to make these. It's 4 sticks and 2 wood (any) as follows: stick wood stick stick wood stick The collision box of the open gate is such that if two gates are connected but mirrored (making an M shape) then you can walk a large entity that's larger than 1.0 wide through the opening. The gate of an opened fence can also be stood upon or bumped into. I've mixed together some sounds to provide a somewhat light sound experience, one that one would expect from a small gate latching open and close. This change requires #873, otherwise it doesn't connect to fences.
2016-02-26 16:30:38 +01:00
})
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
doors.register_fencegate("doors:gate_acacia_wood", {
Make sapling, leaves and fence descriptions consistent (#1795)
2017-06-25 11:19:12 +02:00
description = "Acacia Wood Fence Gate",
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
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", {
Change "Junglewood" to "Jungle Wood"
2017-05-24 23:22:17 +02:00
description = "Jungle Wood Fence Gate",
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
texture = "default_junglewood.png",
material = "default:junglewood",
groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 2}
})
doors.register_fencegate("doors:gate_pine_wood", {
Make sapling, leaves and fence descriptions consistent (#1795)
2017-06-25 11:19:12 +02:00
description = "Pine Wood Fence Gate",
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
texture = "default_pine_wood.png",
material = "default:pine_wood",
Default, stairs, doors: Vary wood flammable and choppy group values Make the softer woods, pine and aspen, 'flammable = 3'. Correct inconsistent flammability of wood and stairs in relation to all other solid wood nodes in MTGame. Make the the softer woods, pine and aspen, 'choppy = 3'.
2016-08-27 03:41:31 +02:00
groups = {choppy = 3, oddly_breakable_by_hand = 2, flammable = 3}
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
})
doors.register_fencegate("doors:gate_aspen_wood", {
Make sapling, leaves and fence descriptions consistent (#1795)
2017-06-25 11:19:12 +02:00
description = "Aspen Wood Fence Gate",
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
texture = "default_aspen_wood.png",
material = "default:aspen_wood",
Default, stairs, doors: Vary wood flammable and choppy group values Make the softer woods, pine and aspen, 'flammable = 3'. Correct inconsistent flammability of wood and stairs in relation to all other solid wood nodes in MTGame. Make the the softer woods, pine and aspen, 'choppy = 3'.
2016-08-27 03:41:31 +02:00
groups = {choppy = 3, oddly_breakable_by_hand = 2, flammable = 3}
Create API for registration of fence gate.
2016-03-18 08:33:14 +01:00
})
Add and edit fuel registrations Edited fuels: fences, wooden ladder. New fuels: boat, paper, book, dry shrub, stick, vessels shelf, wooden tools, wooden door, trapdoor, fence gates, farming crops, stairs, slabs, beds.
2016-10-30 11:29:58 +01:00
----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,
})
Copy Permalink