mods/doors/api.lua

   1 local S = minetest.get_translator("doors")
   2
   3 -- our API object
   4 doors = {}
   5
   6 -- private data
   7 local _doors = {}
   8 _doors.registered_doors = {}
   9 _doors.registered_trapdoors = {}
  10
  11 local function replace_old_owner_information(pos)
  12         local meta = minetest.get_meta(pos)
  13         local owner = meta:get_string("doors_owner")
  14         if owner and owner ~= "" then
  15                 meta:set_string("owner", owner)
  16                 meta:set_string("doors_owner", "")
  17         end
  18 end
  19
  20 local can_interact_with_node = function(player, pos)
  21         if player then
  22                 if minetest.check_player_privs(player, "protection_bypass") then
  23                         return true
  24                 end
  25         else
  26                 return false
  27         end
  28
  29         local meta = minetest.get_meta(pos)
  30         local owner = meta:get_string("owner")
  31
  32         if not owner or owner == "" or owner == player:get_player_name() then
  33                 return true
  34         end
  35
  36         return false
  37 end
  38
  39 -- returns an object to a door object or nil
  40 function doors.get(pos)
  41         local node_name = minetest.get_node(pos).name
  42         if _doors.registered_doors[node_name] then
  43                 -- A normal upright door
  44                 return {
  45                         pos = pos,
  46                         open = function(self, player)
  47                                 if self:state() then
  48                                         return false
  49                                 end
  50                                 return _doors.door_toggle(self.pos, nil, player)
  51                         end,
  52                         close = function(self, player)
  53                                 if not self:state() then
  54                                         return false
  55                                 end
  56                                 return _doors.door_toggle(self.pos, nil, player)
  57                         end,
  58                         toggle = function(self, player)
  59                                 return _doors.door_toggle(self.pos, nil, player)
  60                         end,
  61                         state = function(self)
  62                                 local state = minetest.get_meta(self.pos):get_int("state")
  63                                 return state %2 == 1
  64                         end
  65                 }
  66         elseif _doors.registered_trapdoors[node_name] then
  67                 -- A trapdoor
  68                 return {
  69                         pos = pos,
  70                         open = function(self, player)
  71                                 if self:state() then
  72                                         return false
  73                                 end
  74                                 return _doors.trapdoor_toggle(self.pos, nil, player)
  75                         end,
  76                         close = function(self, player)
  77                                 if not self:state() then
  78                                         return false
  79                                 end
  80                                 return _doors.trapdoor_toggle(self.pos, nil, player)
  81                         end,
  82                         toggle = function(self, player)
  83                                 return _doors.trapdoor_toggle(self.pos, nil, player)
  84                         end,
  85                         state = function(self)
  86                                 return minetest.get_node(self.pos).name:sub(-5) == "_open"
  87                         end
  88                 }
  89         else
  90                 return nil
  91         end
  92 end
  93
  94 -- this hidden node is placed on top of the bottom, and prevents
  95 -- nodes from being placed in the top half of the door.
  96 minetest.register_node("doors:hidden", {
  97         description = S("Hidden Door Segment"),
  98         -- can't use airlike otherwise falling nodes will turn to entities
  99         -- and will be forever stuck until door is removed.
 100         drawtype = "nodebox",
 101         paramtype = "light",
 102         paramtype2 = "facedir",
 103         sunlight_propagates = true,
 104         -- has to be walkable for falling nodes to stop falling.
 105         walkable = true,
 106         pointable = false,
 107         diggable = false,
 108         buildable_to = false,
 109         floodable = false,
 110         drop = "",
 111         groups = {not_in_creative_inventory = 1},
 112         on_blast = function() end,
 113         tiles = {"blank.png"},
 114         use_texture_alpha = true,
 115         -- 1px transparent block inside door hinge near node top.
 116         node_box = {
 117                 type = "fixed",
 118                 fixed = {-15/32, 13/32, -15/32, -13/32, 1/2, -13/32},
 119         },
 120         -- collision_box needed otherise selection box would be full node size
 121         collision_box = {
 122                 type = "fixed",
 123                 fixed = {-15/32, 13/32, -15/32, -13/32, 1/2, -13/32},
 124         },
 125 })
 126
 127 -- table used to aid door opening/closing
 128 local transform = {
 129         {
 130                 {v = "_a", param2 = 3},
 131                 {v = "_a", param2 = 0},
 132                 {v = "_a", param2 = 1},
 133                 {v = "_a", param2 = 2},
 134         },
 135         {
 136                 {v = "_b", param2 = 1},
 137                 {v = "_b", param2 = 2},
 138                 {v = "_b", param2 = 3},
 139                 {v = "_b", param2 = 0},
 140         },
 141         {
 142                 {v = "_b", param2 = 1},
 143                 {v = "_b", param2 = 2},
 144                 {v = "_b", param2 = 3},
 145                 {v = "_b", param2 = 0},
 146         },
 147         {
 148                 {v = "_a", param2 = 3},
 149                 {v = "_a", param2 = 0},
 150                 {v = "_a", param2 = 1},
 151                 {v = "_a", param2 = 2},
 152         },
 153 }
 154
 155 function _doors.door_toggle(pos, node, clicker)
 156         local meta = minetest.get_meta(pos)
 157         node = node or minetest.get_node(pos)
 158         local def = minetest.registered_nodes[node.name]
 159         local name = def.door.name
 160
 161         local state = meta:get_string("state")
 162         if state == "" then
 163                 -- fix up lvm-placed right-hinged doors, default closed
 164                 if node.name:sub(-2) == "_b" then
 165                         state = 2
 166                 else
 167                         state = 0
 168                 end
 169         else
 170                 state = tonumber(state)
 171         end
 172
 173         replace_old_owner_information(pos)
 174
 175         if clicker and not can_interact_with_node(clicker, pos) then
 176                 return false
 177         end
 178
 179         -- until Lua-5.2 we have no bitwise operators :(
 180         if state % 2 == 1 then
 181                 state = state - 1
 182         else
 183                 state = state + 1
 184         end
 185
 186         local dir = node.param2
 187         if state % 2 == 0 then
 188                 minetest.sound_play(def.door.sounds[1],
 189                         {pos = pos, gain = 0.3, max_hear_distance = 10}, true)
 190         else
 191                 minetest.sound_play(def.door.sounds[2],
 192                         {pos = pos, gain = 0.3, max_hear_distance = 10}, true)
 193         end
 194
 195         minetest.swap_node(pos, {
 196                 name = name .. transform[state + 1][dir+1].v,
 197                 param2 = transform[state + 1][dir+1].param2
 198         })
 199         meta:set_int("state", state)
 200
 201         return true
 202 end
 203
 204
 205 local function on_place_node(place_to, newnode,
 206         placer, oldnode, itemstack, pointed_thing)
 207         -- Run script hook
 208         for _, callback in ipairs(minetest.registered_on_placenodes) do
 209                 -- Deepcopy pos, node and pointed_thing because callback can modify them
 210                 local place_to_copy = {x = place_to.x, y = place_to.y, z = place_to.z}
 211                 local newnode_copy =
 212                         {name = newnode.name, param1 = newnode.param1, param2 = newnode.param2}
 213                 local oldnode_copy =
 214                         {name = oldnode.name, param1 = oldnode.param1, param2 = oldnode.param2}
 215                 local pointed_thing_copy = {
 216                         type  = pointed_thing.type,
 217                         above = vector.new(pointed_thing.above),
 218                         under = vector.new(pointed_thing.under),
 219                         ref   = pointed_thing.ref,
 220                 }
 221                 callback(place_to_copy, newnode_copy, placer,
 222                         oldnode_copy, itemstack, pointed_thing_copy)
 223         end
 224 end
 225
 226 local function can_dig_door(pos, digger)
 227         replace_old_owner_information(pos)
 228         if can_interact_with_node(digger, pos) then
 229                 return true
 230         else
 231                 minetest.record_protection_violation(pos, digger:get_player_name())
 232                 return false
 233         end
 234 end
 235
 236 function doors.register(name, def)
 237         if not name:find(":") then
 238                 name = "doors:" .. name
 239         end
 240
 241         minetest.register_craftitem(":" .. name, {
 242                 description = def.description,
 243                 inventory_image = def.inventory_image,
 244                 groups = table.copy(def.groups),
 245
 246                 on_place = function(itemstack, placer, pointed_thing)
 247                         local pos
 248
 249                         if not pointed_thing.type == "node" then
 250                                 return itemstack
 251                         end
 252
 253                         local node = minetest.get_node(pointed_thing.under)
 254                         local pdef = minetest.registered_nodes[node.name]
 255                         if pdef and pdef.on_rightclick and
 256                                         not placer:get_player_control().sneak then
 257                                 return pdef.on_rightclick(pointed_thing.under,
 258                                                 node, placer, itemstack, pointed_thing)
 259                         end
 260
 261                         if pdef and pdef.buildable_to then
 262                                 pos = pointed_thing.under
 263                         else
 264                                 pos = pointed_thing.above
 265                                 node = minetest.get_node(pos)
 266                                 pdef = minetest.registered_nodes[node.name]
 267                                 if not pdef or not pdef.buildable_to then
 268                                         return itemstack
 269                                 end
 270                         end
 271
 272                         local above = {x = pos.x, y = pos.y + 1, z = pos.z}
 273                         local top_node = minetest.get_node_or_nil(above)
 274                         local topdef = top_node and minetest.registered_nodes[top_node.name]
 275
 276                         if not topdef or not topdef.buildable_to then
 277                                 return itemstack
 278                         end
 279
 280                         local pn = placer:get_player_name()
 281                         if minetest.is_protected(pos, pn) or minetest.is_protected(above, pn) then
 282                                 return itemstack
 283                         end
 284
 285                         local dir = minetest.dir_to_facedir(placer:get_look_dir())
 286
 287                         local ref = {
 288                                 {x = -1, y = 0, z = 0},
 289                                 {x = 0, y = 0, z = 1},
 290                                 {x = 1, y = 0, z = 0},
 291                                 {x = 0, y = 0, z = -1},
 292                         }
 293
 294                         local aside = {
 295                                 x = pos.x + ref[dir + 1].x,
 296                                 y = pos.y + ref[dir + 1].y,
 297                                 z = pos.z + ref[dir + 1].z,
 298                         }
 299
 300                         local state = 0
 301                         if minetest.get_item_group(minetest.get_node(aside).name, "door") == 1 then
 302                                 state = state + 2
 303                                 minetest.set_node(pos, {name = name .. "_b", param2 = dir})
 304                                 minetest.set_node(above, {name = "doors:hidden", param2 = (dir + 3) % 4})
 305                         else
 306                                 minetest.set_node(pos, {name = name .. "_a", param2 = dir})
 307                                 minetest.set_node(above, {name = "doors:hidden", param2 = dir})
 308                         end
 309
 310                         local meta = minetest.get_meta(pos)
 311                         meta:set_int("state", state)
 312
 313                         if def.protected then
 314                                 meta:set_string("owner", pn)
 315                                 meta:set_string("infotext", S("Owned by @1", pn))
 316                         end
 317
 318                         if not (creative and creative.is_enabled_for and creative.is_enabled_for(pn)) then
 319                                 itemstack:take_item()
 320                         end
 321
 322                         minetest.sound_play(def.sounds.place, {pos = pos}, true)
 323
 324                         on_place_node(pos, minetest.get_node(pos),
 325                                 placer, node, itemstack, pointed_thing)
 326
 327                         return itemstack
 328                 end
 329         })
 330         def.inventory_image = nil
 331
 332         if def.recipe then
 333                 minetest.register_craft({
 334                         output = name,
 335                         recipe = def.recipe,
 336                 })
 337         end
 338         def.recipe = nil
 339
 340         if not def.sounds then
 341                 def.sounds = hades_sounds.node_sound_wood_defaults()
 342         end
 343
 344         if not def.sound_open then
 345                 def.sound_open = "doors_door_open"
 346         end
 347
 348         if not def.sound_close then
 349                 def.sound_close = "doors_door_close"
 350         end
 351
 352         def.groups.not_in_creative_inventory = 1
 353         def.groups.door = 1
 354         def.drop = name
 355         def.door = {
 356                 name = name,
 357                 sounds = { def.sound_close, def.sound_open },
 358         }
 359
 360         def.on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
 361                 _doors.door_toggle(pos, node, clicker)
 362                 return itemstack
 363         end
 364         def.after_dig_node = function(pos, node, meta, digger)
 365                 minetest.remove_node({x = pos.x, y = pos.y + 1, z = pos.z})
 366                 minetest.check_for_falling({x = pos.x, y = pos.y + 1, z = pos.z})
 367         end
 368         def.on_rotate = function(pos, node, user, mode, new_param2)
 369                 return false
 370         end
 371
 372         if def.protected then
 373                 def.can_dig = can_dig_door
 374                 def.on_blast = function() end
 375                 def.on_key_use = function(pos, player)
 376                         local door = doors.get(pos)
 377                         door:toggle(player)
 378                 end
 379                 def.on_skeleton_key_use = function(pos, player, newsecret)
 380                         replace_old_owner_information(pos)
 381                         local meta = minetest.get_meta(pos)
 382                         local owner = meta:get_string("owner")
 383                         local pname = player:get_player_name()
 384
 385                         -- verify placer is owner of lockable door
 386                         if owner ~= pname then
 387                                 minetest.record_protection_violation(pos, pname)
 388                                 minetest.chat_send_player(pname, S("You do not own this locked door."))
 389                                 return nil
 390                         end
 391
 392                         local secret = meta:get_string("key_lock_secret")
 393                         if secret == "" then
 394                                 secret = newsecret
 395                                 meta:set_string("key_lock_secret", secret)
 396                         end
 397
 398                         return secret, "a locked door", owner
 399                 end
 400         else
 401                 def.on_blast = function(pos, intensity)
 402                         minetest.remove_node(pos)
 403                         -- hidden node doesn't get blasted away.
 404                         minetest.remove_node({x = pos.x, y = pos.y + 1, z = pos.z})
 405                         return {name}
 406                 end
 407         end
 408
 409         def.on_destruct = function(pos)
 410                 minetest.remove_node({x = pos.x, y = pos.y + 1, z = pos.z})
 411         end
 412
 413         def.drawtype = "mesh"
 414         def.paramtype = "light"
 415         def.paramtype2 = "facedir"
 416         def.sunlight_propagates = true
 417         def.walkable = true
 418         def.is_ground_content = false
 419         def.buildable_to = false
 420         def.selection_box = {type = "fixed", fixed = {-1/2,-1/2,-1/2,1/2,3/2,-6/16}}
 421         def.collision_box = {type = "fixed", fixed = {-1/2,-1/2,-1/2,1/2,3/2,-6/16}}
 422
 423         def.mesh = "door_a.obj"
 424         minetest.register_node(":" .. name .. "_a", def)
 425
 426         def.mesh = "door_b.obj"
 427         minetest.register_node(":" .. name .. "_b", def)
 428
 429         _doors.registered_doors[name .. "_a"] = true
 430         _doors.registered_doors[name .. "_b"] = true
 431 end
 432
 433 -- Capture mods using the old API as best as possible.
 434 function doors.register_door(name, def)
 435         if def.only_placer_can_open then
 436                 def.protected = true
 437         end
 438         def.only_placer_can_open = nil
 439
 440         local i = name:find(":")
 441         local modname = name:sub(1, i - 1)
 442         if not def.tiles then
 443                 if def.protected then
 444                         def.tiles = {{name = "doors_door_steel.png", backface_culling = true}}
 445                 else
 446                         def.tiles = {{name = "doors_door_wood.png", backface_culling = true}}
 447                 end
 448                 minetest.log("warning", modname .. " registered door \"" .. name .. "\" " ..
 449                                 "using deprecated API method \"doors.register_door()\" but " ..
 450                                 "did not provide the \"tiles\" parameter. A fallback tiledef " ..
 451                                 "will be used instead.")
 452         end
 453         def.use_texture_alpha = true
 454
 455         doors.register(name, def)
 456 end
 457
 458 ----trapdoor----
 459
 460 function _doors.trapdoor_toggle(pos, node, clicker)
 461         node = node or minetest.get_node(pos)
 462
 463         replace_old_owner_information(pos)
 464
 465         if clicker and not can_interact_with_node(clicker, pos) then
 466                 return false
 467         end
 468
 469         local def = minetest.registered_nodes[node.name]
 470
 471         if string.sub(node.name, -5) == "_open" then
 472                 minetest.sound_play(def.sound_close,
 473                         {pos = pos, gain = 0.3, max_hear_distance = 10}, true)
 474                 minetest.swap_node(pos, {name = string.sub(node.name, 1,
 475                         string.len(node.name) - 5), param1 = node.param1, param2 = node.param2})
 476         else
 477                 minetest.sound_play(def.sound_open,
 478                         {pos = pos, gain = 0.3, max_hear_distance = 10}, true)
 479                 minetest.swap_node(pos, {name = node.name .. "_open",
 480                         param1 = node.param1, param2 = node.param2})
 481         end
 482 end
 483
 484 function doors.register_trapdoor(name, def)
 485         if not name:find(":") then
 486                 name = "doors:" .. name
 487         end
 488
 489         local name_closed = name
 490         local name_opened = name.."_open"
 491
 492         def.on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
 493                 _doors.trapdoor_toggle(pos, node, clicker)
 494                 return itemstack
 495         end
 496
 497         -- Common trapdoor configuration
 498         def.drawtype = "nodebox"
 499         def.paramtype = "light"
 500         def.paramtype2 = "facedir"
 501         def.is_ground_content = false
 502
 503         if def.protected then
 504                 def.can_dig = can_dig_door
 505                 def.after_place_node = function(pos, placer, itemstack, pointed_thing)
 506                         local pn = placer:get_player_name()
 507                         local meta = minetest.get_meta(pos)
 508                         meta:set_string("owner", pn)
 509                         meta:set_string("infotext", S("Owned by @1", pn))
 510
 511                         return (creative and creative.is_enabled_for and creative.is_enabled_for(pn))
 512                 end
 513
 514                 def.on_blast = function() end
 515                 def.on_key_use = function(pos, player)
 516                         local door = doors.get(pos)
 517                         door:toggle(player)
 518                 end
 519                 def.on_skeleton_key_use = function(pos, player, newsecret)
 520                         replace_old_owner_information(pos)
 521                         local meta = minetest.get_meta(pos)
 522                         local owner = meta:get_string("owner")
 523                         local pname = player:get_player_name()
 524
 525                         -- verify placer is owner of lockable door
 526                         if owner ~= pname then
 527                                 minetest.record_protection_violation(pos, pname)
 528                                 minetest.chat_send_player(pname, S("You do not own this trapdoor."))
 529                                 return nil
 530                         end
 531
 532                         local secret = meta:get_string("key_lock_secret")
 533                         if secret == "" then
 534                                 secret = newsecret
 535                                 meta:set_string("key_lock_secret", secret)
 536                         end
 537
 538                         return secret, "a locked trapdoor", owner
 539                 end
 540         else
 541                 def.on_blast = function(pos, intensity)
 542                         minetest.remove_node(pos)
 543                         return {name}
 544                 end
 545         end
 546
 547         if not def.sounds then
 548                 def.sounds = hades_sounds.node_sound_wood_defaults()
 549         end
 550
 551         if not def.sound_open then
 552                 def.sound_open = "doors_door_open"
 553         end
 554
 555         if not def.sound_close then
 556                 def.sound_close = "doors_door_close"
 557         end
 558
 559         local def_opened = table.copy(def)
 560         local def_closed = table.copy(def)
 561
 562         def_closed.node_box = {
 563                 type = "fixed",
 564                 fixed = {-0.5, -0.5, -0.5, 0.5, -6/16, 0.5}
 565         }
 566         def_closed.selection_box = {
 567                 type = "fixed",
 568                 fixed = {-0.5, -0.5, -0.5, 0.5, -6/16, 0.5}
 569         }
 570         def_closed.tiles = {def.tile_front,
 571                         def.tile_front .. '^[transformFY',
 572                         def.tile_side, def.tile_side,
 573                         def.tile_side, def.tile_side}
 574
 575         def_opened.node_box = {
 576                 type = "fixed",
 577                 fixed = {-0.5, -0.5, 6/16, 0.5, 0.5, 0.5}
 578         }
 579         def_opened.selection_box = {
 580                 type = "fixed",
 581                 fixed = {-0.5, -0.5, 6/16, 0.5, 0.5, 0.5}
 582         }
 583         def_opened.tiles = {def.tile_side, def.tile_side,
 584                         def.tile_side .. '^[transform3',
 585                         def.tile_side .. '^[transform1',
 586                         def.tile_front .. '^[transform46',
 587                         def.tile_front .. '^[transform6'}
 588
 589         def_opened.drop = name_closed
 590         def_opened.groups.not_in_creative_inventory = 1
 591
 592         minetest.register_node(name_opened, def_opened)
 593         minetest.register_node(name_closed, def_closed)
 594
 595         _doors.registered_trapdoors[name_opened] = true
 596         _doors.registered_trapdoors[name_closed] = true
 597 end
 598
 599
 600 ----fence gate----
 601
 602 function doors.register_fencegate(name, def)
 603         local fence = {
 604                 description = def.description,
 605                 drawtype = "mesh",
 606                 tiles = {def.texture},
 607                 paramtype = "light",
 608                 paramtype2 = "facedir",
 609                 sunlight_propagates = true,
 610                 is_ground_content = false,
 611                 drop = name .. "_closed",
 612                 connect_sides = {"left", "right"},
 613                 groups = def.groups,
 614                 sounds = def.sounds,
 615                 on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
 616                         local node_def = minetest.registered_nodes[node.name]
 617                         minetest.swap_node(pos, {name = node_def.gate, param2 = node.param2})
 618                         minetest.sound_play(node_def.sound, {pos = pos, gain = 0.3,
 619                                 max_hear_distance = 8}, true)
 620                         return itemstack
 621                 end,
 622                 selection_box = {
 623                         type = "fixed",
 624                         fixed = {-1/2, -1/2, -1/4, 1/2, 1/2, 1/4},
 625                 },
 626         }
 627
 628         if not fence.sounds then
 629                 fence.sounds = hades_sounds.node_sound_wood_defaults()
 630         end
 631
 632         fence.groups.fence = 1
 633         fence.groups.fence_gate = 1
 634
 635         local fence_closed = table.copy(fence)
 636         fence_closed.mesh = "doors_fencegate_closed.obj"
 637         fence_closed.gate = name .. "_open"
 638         fence_closed.sound = "doors_fencegate_open"
 639         fence_closed.collision_box = {
 640                 type = "fixed",
 641                 fixed = {-1/2, -1/2, -1/4, 1/2, 1/2, 1/4},
 642         }
 643
 644         local fence_open = table.copy(fence)
 645         fence_open.mesh = "doors_fencegate_open.obj"
 646         fence_open.gate = name .. "_closed"
 647         fence_open.sound = "doors_fencegate_close"
 648         fence_open.groups.not_in_creative_inventory = 1
 649         fence_open.collision_box = {
 650                 type = "fixed",
 651                 fixed = {{-1/2, -1/2, -1/4, -3/8, 1/2, 1/4},
 652                         {-1/2, -3/8, -1/2, -3/8, 3/8, 0}},
 653         }
 654
 655         minetest.register_node(":" .. name .. "_closed", fence_closed)
 656         minetest.register_node(":" .. name .. "_open", fence_open)
 657
 658         minetest.register_craft({
 659                 output = name .. "_closed",
 660                 recipe = {
 661                         {"group:stick", def.material, "group:stick"},
 662                         {"group:stick", def.material, "group:stick"}
 663                 }
 664         })
 665 end
 666