mods/default/trees.lua

   1 local random = math.random
   2
   3 --
   4 -- Grow trees from saplings
   5 --
   6
   7 -- 'can grow' function
   8
   9 function default.can_grow(pos)
  10         local node_under = minetest.get_node_or_nil({x = pos.x, y = pos.y - 1, z = pos.z})
  11         if not node_under then
  12                 return false
  13         end
  14         local name_under = node_under.name
  15         local is_soil = minetest.get_item_group(name_under, "soil")
  16         if is_soil == 0 then
  17                 return false
  18         end
  19         local light_level = minetest.get_node_light(pos)
  20         if not light_level or light_level < 13 then
  21                 return false
  22         end
  23         return true
  24 end
  25
  26
  27 -- 'is snow nearby' function
  28
  29 local function is_snow_nearby(pos)
  30         return minetest.find_node_near(pos, 1, {"group:snowy"})
  31 end
  32
  33
  34 -- Grow sapling
  35
  36 function default.grow_sapling(pos)
  37         if not default.can_grow(pos) then
  38                 -- try again 5 min later
  39                 minetest.get_node_timer(pos):start(300)
  40                 return
  41         end
  42
  43         local mg_name = minetest.get_mapgen_setting("mg_name")
  44         local node = minetest.get_node(pos)
  45         if node.name == "default:sapling" then
  46                 minetest.log("action", "A sapling grows into a tree at "..
  47                         minetest.pos_to_string(pos))
  48                 if mg_name == "v6" then
  49                         default.grow_tree(pos, random(1, 4) == 1)
  50                 else
  51                         default.grow_new_apple_tree(pos)
  52                 end
  53         elseif node.name == "default:junglesapling" then
  54                 minetest.log("action", "A jungle sapling grows into a tree at "..
  55                         minetest.pos_to_string(pos))
  56                 if mg_name == "v6" then
  57                         default.grow_jungle_tree(pos)
  58                 else
  59                         default.grow_new_jungle_tree(pos)
  60                 end
  61         elseif node.name == "default:pine_sapling" then
  62                 minetest.log("action", "A pine sapling grows into a tree at "..
  63                         minetest.pos_to_string(pos))
  64                 local snow = is_snow_nearby(pos)
  65                 if mg_name == "v6" then
  66                         default.grow_pine_tree(pos, snow)
  67                 elseif snow then
  68                         default.grow_new_snowy_pine_tree(pos)
  69                 else
  70                         default.grow_new_pine_tree(pos)
  71                 end
  72         elseif node.name == "default:acacia_sapling" then
  73                 minetest.log("action", "An acacia sapling grows into a tree at "..
  74                         minetest.pos_to_string(pos))
  75                 default.grow_new_acacia_tree(pos)
  76         elseif node.name == "default:aspen_sapling" then
  77                 minetest.log("action", "An aspen sapling grows into a tree at "..
  78                         minetest.pos_to_string(pos))
  79                 default.grow_new_aspen_tree(pos)
  80         elseif node.name == "default:bush_sapling" then
  81                 minetest.log("action", "A bush sapling grows into a bush at "..
  82                         minetest.pos_to_string(pos))
  83                 default.grow_bush(pos)
  84         elseif node.name == "default:blueberry_bush_sapling" then
  85                 minetest.log("action", "A blueberry bush sapling grows into a bush at "..
  86                         minetest.pos_to_string(pos))
  87                 default.grow_blueberry_bush(pos)
  88         elseif node.name == "default:acacia_bush_sapling" then
  89                 minetest.log("action", "An acacia bush sapling grows into a bush at "..
  90                         minetest.pos_to_string(pos))
  91                 default.grow_acacia_bush(pos)
  92         elseif node.name == "default:pine_bush_sapling" then
  93                 minetest.log("action", "A pine bush sapling grows into a bush at "..
  94                         minetest.pos_to_string(pos))
  95                 default.grow_pine_bush(pos)
  96         elseif node.name == "default:emergent_jungle_sapling" then
  97                 minetest.log("action", "An emergent jungle sapling grows into a tree at "..
  98                         minetest.pos_to_string(pos))
  99                 default.grow_new_emergent_jungle_tree(pos)
 100         end
 101 end
 102
 103 minetest.register_lbm({
 104         name = "default:convert_saplings_to_node_timer",
 105         nodenames = {"default:sapling", "default:junglesapling",
 106                         "default:pine_sapling", "default:acacia_sapling",
 107                         "default:aspen_sapling"},
 108         action = function(pos)
 109                 minetest.get_node_timer(pos):start(math.random(300, 1500))
 110         end
 111 })
 112
 113 --
 114 -- Tree generation
 115 --
 116
 117 -- Apple tree and jungle tree trunk and leaves function
 118
 119 local function add_trunk_and_leaves(data, a, pos, tree_cid, leaves_cid,
 120                 height, size, iters, is_apple_tree)
 121         local x, y, z = pos.x, pos.y, pos.z
 122         local c_air = minetest.get_content_id("air")
 123         local c_ignore = minetest.get_content_id("ignore")
 124         local c_apple = minetest.get_content_id("default:apple")
 125
 126         -- Trunk
 127         data[a:index(x, y, z)] = tree_cid -- Force-place lowest trunk node to replace sapling
 128         for yy = y + 1, y + height - 1 do
 129                 local vi = a:index(x, yy, z)
 130                 local node_id = data[vi]
 131                 if node_id == c_air or node_id == c_ignore or node_id == leaves_cid then
 132                         data[vi] = tree_cid
 133                 end
 134         end
 135
 136         -- Force leaves near the trunk
 137         for z_dist = -1, 1 do
 138         for y_dist = -size, 1 do
 139                 local vi = a:index(x - 1, y + height + y_dist, z + z_dist)
 140                 for x_dist = -1, 1 do
 141                         if data[vi] == c_air or data[vi] == c_ignore then
 142                                 if is_apple_tree and random(1, 8) == 1 then
 143                                         data[vi] = c_apple
 144                                 else
 145                                         data[vi] = leaves_cid
 146                                 end
 147                         end
 148                         vi = vi + 1
 149                 end
 150         end
 151         end
 152
 153         -- Randomly add leaves in 2x2x2 clusters.
 154         for i = 1, iters do
 155                 local clust_x = x + random(-size, size - 1)
 156                 local clust_y = y + height + random(-size, 0)
 157                 local clust_z = z + random(-size, size - 1)
 158
 159                 for xi = 0, 1 do
 160                 for yi = 0, 1 do
 161                 for zi = 0, 1 do
 162                         local vi = a:index(clust_x + xi, clust_y + yi, clust_z + zi)
 163                         if data[vi] == c_air or data[vi] == c_ignore then
 164                                 if is_apple_tree and random(1, 8) == 1 then
 165                                         data[vi] = c_apple
 166                                 else
 167                                         data[vi] = leaves_cid
 168                                 end
 169                         end
 170                 end
 171                 end
 172                 end
 173         end
 174 end
 175
 176
 177 -- Apple tree
 178
 179 function default.grow_tree(pos, is_apple_tree, bad)
 180         --[[
 181                 NOTE: Tree-placing code is currently duplicated in the engine
 182                 and in games that have saplings; both are deprecated but not
 183                 replaced yet
 184         --]]
 185         if bad then
 186                 error("Deprecated use of default.grow_tree")
 187         end
 188
 189         local x, y, z = pos.x, pos.y, pos.z
 190         local height = random(4, 5)
 191         local c_tree = minetest.get_content_id("default:tree")
 192         local c_leaves = minetest.get_content_id("default:leaves")
 193
 194         local vm = minetest.get_voxel_manip()
 195         local minp, maxp = vm:read_from_map(
 196                 {x = x - 2, y = y, z = z - 2},
 197                 {x = x + 2, y = y + height + 1, z = z + 2}
 198         )
 199         local a = VoxelArea:new({MinEdge = minp, MaxEdge = maxp})
 200         local data = vm:get_data()
 201
 202         add_trunk_and_leaves(data, a, pos, c_tree, c_leaves, height, 2, 8, is_apple_tree)
 203
 204         vm:set_data(data)
 205         vm:write_to_map()
 206         vm:update_map()
 207 end
 208
 209
 210 -- Jungle tree
 211
 212 function default.grow_jungle_tree(pos, bad)
 213         --[[
 214                 NOTE: Jungletree-placing code is currently duplicated in the engine
 215                 and in games that have saplings; both are deprecated but not
 216                 replaced yet
 217         --]]
 218         if bad then
 219                 error("Deprecated use of default.grow_jungle_tree")
 220         end
 221
 222         local x, y, z = pos.x, pos.y, pos.z
 223         local height = random(8, 12)
 224         local c_air = minetest.get_content_id("air")
 225         local c_ignore = minetest.get_content_id("ignore")
 226         local c_jungletree = minetest.get_content_id("default:jungletree")
 227         local c_jungleleaves = minetest.get_content_id("default:jungleleaves")
 228
 229         local vm = minetest.get_voxel_manip()
 230         local minp, maxp = vm:read_from_map(
 231                 {x = x - 3, y = y - 1, z = z - 3},
 232                 {x = x + 3, y = y + height + 1, z = z + 3}
 233         )
 234         local a = VoxelArea:new({MinEdge = minp, MaxEdge = maxp})
 235         local data = vm:get_data()
 236
 237         add_trunk_and_leaves(data, a, pos, c_jungletree, c_jungleleaves,
 238                 height, 3, 30, false)
 239
 240         -- Roots
 241         for z_dist = -1, 1 do
 242                 local vi_1 = a:index(x - 1, y - 1, z + z_dist)
 243                 local vi_2 = a:index(x - 1, y, z + z_dist)
 244                 for x_dist = -1, 1 do
 245                         if random(1, 3) >= 2 then
 246                                 if data[vi_1] == c_air or data[vi_1] == c_ignore then
 247                                         data[vi_1] = c_jungletree
 248                                 elseif data[vi_2] == c_air or data[vi_2] == c_ignore then
 249                                         data[vi_2] = c_jungletree
 250                                 end
 251                         end
 252                         vi_1 = vi_1 + 1
 253                         vi_2 = vi_2 + 1
 254                 end
 255         end
 256
 257         vm:set_data(data)
 258         vm:write_to_map()
 259         vm:update_map()
 260 end
 261
 262
 263 -- Pine tree from mg mapgen mod, design by sfan5, pointy top added by paramat
 264
 265 local function add_pine_needles(data, vi, c_air, c_ignore, c_snow, c_pine_needles)
 266         local node_id = data[vi]
 267         if node_id == c_air or node_id == c_ignore or node_id == c_snow then
 268                 data[vi] = c_pine_needles
 269         end
 270 end
 271
 272 local function add_snow(data, vi, c_air, c_ignore, c_snow)
 273         local node_id = data[vi]
 274         if node_id == c_air or node_id == c_ignore then
 275                 data[vi] = c_snow
 276         end
 277 end
 278
 279 function default.grow_pine_tree(pos, snow)
 280         local x, y, z = pos.x, pos.y, pos.z
 281         local maxy = y + random(9, 13) -- Trunk top
 282
 283         local c_air = minetest.get_content_id("air")
 284         local c_ignore = minetest.get_content_id("ignore")
 285         local c_pine_tree = minetest.get_content_id("default:pine_tree")
 286         local c_pine_needles  = minetest.get_content_id("default:pine_needles")
 287         local c_snow = minetest.get_content_id("default:snow")
 288
 289         local vm = minetest.get_voxel_manip()
 290         local minp, maxp = vm:read_from_map(
 291                 {x = x - 3, y = y, z = z - 3},
 292                 {x = x + 3, y = maxy + 3, z = z + 3}
 293         )
 294         local a = VoxelArea:new({MinEdge = minp, MaxEdge = maxp})
 295         local data = vm:get_data()
 296
 297         -- Upper branches layer
 298         local dev = 3
 299         for yy = maxy - 1, maxy + 1 do
 300                 for zz = z - dev, z + dev do
 301                         local vi = a:index(x - dev, yy, zz)
 302                         local via = a:index(x - dev, yy + 1, zz)
 303                         for xx = x - dev, x + dev do
 304                                 if random() < 0.95 - dev * 0.05 then
 305                                         add_pine_needles(data, vi, c_air, c_ignore, c_snow,
 306                                                 c_pine_needles)
 307                                         if snow then
 308                                                 add_snow(data, via, c_air, c_ignore, c_snow)
 309                                         end
 310                                 end
 311                                 vi  = vi + 1
 312                                 via = via + 1
 313                         end
 314                 end
 315                 dev = dev - 1
 316         end
 317
 318         -- Centre top nodes
 319         add_pine_needles(data, a:index(x, maxy + 1, z), c_air, c_ignore, c_snow,
 320                 c_pine_needles)
 321         add_pine_needles(data, a:index(x, maxy + 2, z), c_air, c_ignore, c_snow,
 322                 c_pine_needles) -- Paramat added a pointy top node
 323         if snow then
 324                 add_snow(data, a:index(x, maxy + 3, z), c_air, c_ignore, c_snow)
 325         end
 326
 327         -- Lower branches layer
 328         local my = 0
 329         for i = 1, 20 do -- Random 2x2 squares of needles
 330                 local xi = x + random(-3, 2)
 331                 local yy = maxy + random(-6, -5)
 332                 local zi = z + random(-3, 2)
 333                 if yy > my then
 334                         my = yy
 335                 end
 336                 for zz = zi, zi+1 do
 337                         local vi = a:index(xi, yy, zz)
 338                         local via = a:index(xi, yy + 1, zz)
 339                         for xx = xi, xi + 1 do
 340                                 add_pine_needles(data, vi, c_air, c_ignore, c_snow,
 341                                         c_pine_needles)
 342                                 if snow then
 343                                         add_snow(data, via, c_air, c_ignore, c_snow)
 344                                 end
 345                                 vi  = vi + 1
 346                                 via = via + 1
 347                         end
 348                 end
 349         end
 350
 351         dev = 2
 352         for yy = my + 1, my + 2 do
 353                 for zz = z - dev, z + dev do
 354                         local vi = a:index(x - dev, yy, zz)
 355                         local via = a:index(x - dev, yy + 1, zz)
 356                         for xx = x - dev, x + dev do
 357                                 if random() < 0.95 - dev * 0.05 then
 358                                         add_pine_needles(data, vi, c_air, c_ignore, c_snow,
 359                                                 c_pine_needles)
 360                                         if snow then
 361                                                 add_snow(data, via, c_air, c_ignore, c_snow)
 362                                         end
 363                                 end
 364                                 vi  = vi + 1
 365                                 via = via + 1
 366                         end
 367                 end
 368                 dev = dev - 1
 369         end
 370
 371         -- Trunk
 372         -- Force-place lowest trunk node to replace sapling
 373         data[a:index(x, y, z)] = c_pine_tree
 374         for yy = y + 1, maxy do
 375                 local vi = a:index(x, yy, z)
 376                 local node_id = data[vi]
 377                 if node_id == c_air or node_id == c_ignore or
 378                                 node_id == c_pine_needles or node_id == c_snow then
 379                         data[vi] = c_pine_tree
 380                 end
 381         end
 382
 383         vm:set_data(data)
 384         vm:write_to_map()
 385         vm:update_map()
 386 end
 387
 388
 389 -- New apple tree
 390
 391 function default.grow_new_apple_tree(pos)
 392         local path = minetest.get_modpath("default") ..
 393                 "/schematics/apple_tree_from_sapling.mts"
 394         minetest.place_schematic({x = pos.x - 3, y = pos.y - 1, z = pos.z - 3},
 395                 path, "random", nil, false)
 396 end
 397
 398
 399 -- New jungle tree
 400
 401 function default.grow_new_jungle_tree(pos)
 402         local path = minetest.get_modpath("default") ..
 403                 "/schematics/jungle_tree_from_sapling.mts"
 404         minetest.place_schematic({x = pos.x - 2, y = pos.y - 1, z = pos.z - 2},
 405                 path, "random", nil, false)
 406 end
 407
 408
 409 -- New emergent jungle tree
 410
 411 function default.grow_new_emergent_jungle_tree(pos)
 412         local path = minetest.get_modpath("default") ..
 413                 "/schematics/emergent_jungle_tree_from_sapling.mts"
 414         minetest.place_schematic({x = pos.x - 3, y = pos.y - 5, z = pos.z - 3},
 415                 path, "random", nil, false)
 416 end
 417
 418
 419 -- New pine tree
 420
 421 function default.grow_new_pine_tree(pos)
 422         local path
 423         if math.random() > 0.5 then
 424                 path = minetest.get_modpath("default") ..
 425                         "/schematics/pine_tree_from_sapling.mts"
 426         else
 427                 path = minetest.get_modpath("default") ..
 428                         "/schematics/small_pine_tree_from_sapling.mts"
 429         end
 430         minetest.place_schematic({x = pos.x - 2, y = pos.y - 1, z = pos.z - 2},
 431                 path, "0", nil, false)
 432 end
 433
 434
 435 -- New snowy pine tree
 436
 437 function default.grow_new_snowy_pine_tree(pos)
 438         local path
 439         if math.random() > 0.5 then
 440                 path = minetest.get_modpath("default") ..
 441                         "/schematics/snowy_pine_tree_from_sapling.mts"
 442         else
 443                 path = minetest.get_modpath("default") ..
 444                         "/schematics/snowy_small_pine_tree_from_sapling.mts"
 445         end
 446         minetest.place_schematic({x = pos.x - 2, y = pos.y - 1, z = pos.z - 2},
 447                 path, "random", nil, false)
 448 end
 449
 450
 451 -- New acacia tree
 452
 453 function default.grow_new_acacia_tree(pos)
 454         local path = minetest.get_modpath("default") ..
 455                 "/schematics/acacia_tree_from_sapling.mts"
 456         minetest.place_schematic({x = pos.x - 4, y = pos.y - 1, z = pos.z - 4},
 457                 path, "random", nil, false)
 458 end
 459
 460
 461 -- New aspen tree
 462
 463 function default.grow_new_aspen_tree(pos)
 464         local path = minetest.get_modpath("default") ..
 465                 "/schematics/aspen_tree_from_sapling.mts"
 466         minetest.place_schematic({x = pos.x - 2, y = pos.y - 1, z = pos.z - 2},
 467                 path, "0", nil, false)
 468 end
 469
 470
 471 -- Bushes do not need 'from sapling' schematic variants because
 472 -- only the stem node is force-placed in the schematic.
 473
 474 -- Bush
 475
 476 function default.grow_bush(pos)
 477         local path = minetest.get_modpath("default") ..
 478                 "/schematics/bush.mts"
 479         minetest.place_schematic({x = pos.x - 1, y = pos.y - 1, z = pos.z - 1},
 480                 path, "0", nil, false)
 481 end
 482
 483 -- Blueberry bush
 484
 485 function default.grow_blueberry_bush(pos)
 486         local path = minetest.get_modpath("default") ..
 487                 "/schematics/blueberry_bush.mts"
 488         minetest.place_schematic({x = pos.x - 1, y = pos.y, z = pos.z - 1},
 489                 path, "0", nil, false)
 490 end
 491
 492
 493 -- Acacia bush
 494
 495 function default.grow_acacia_bush(pos)
 496         local path = minetest.get_modpath("default") ..
 497                 "/schematics/acacia_bush.mts"
 498         minetest.place_schematic({x = pos.x - 1, y = pos.y - 1, z = pos.z - 1},
 499                 path, "0", nil, false)
 500 end
 501
 502
 503 -- Pine bush
 504
 505 function default.grow_pine_bush(pos)
 506         local path = minetest.get_modpath("default") ..
 507                 "/schematics/pine_bush.mts"
 508         minetest.place_schematic({x = pos.x - 1, y = pos.y - 1, z = pos.z - 1},
 509                 path, "0", nil, false)
 510 end
 511
 512
 513 --
 514 -- Sapling 'on place' function to check protection of node and resulting tree volume
 515 --
 516
 517 function default.sapling_on_place(itemstack, placer, pointed_thing,
 518                 sapling_name, minp_relative, maxp_relative, interval)
 519         -- Position of sapling
 520         local pos = pointed_thing.under
 521         local node = minetest.get_node_or_nil(pos)
 522         local pdef = node and minetest.registered_nodes[node.name]
 523
 524         if pdef and pdef.on_rightclick and
 525                         not (placer and placer:is_player() and
 526                         placer:get_player_control().sneak) then
 527                 return pdef.on_rightclick(pos, node, placer, itemstack, pointed_thing)
 528         end
 529
 530         if not pdef or not pdef.buildable_to then
 531                 pos = pointed_thing.above
 532                 node = minetest.get_node_or_nil(pos)
 533                 pdef = node and minetest.registered_nodes[node.name]
 534                 if not pdef or not pdef.buildable_to then
 535                         return itemstack
 536                 end
 537         end
 538
 539         local player_name = placer and placer:get_player_name() or ""
 540         -- Check sapling position for protection
 541         if minetest.is_protected(pos, player_name) then
 542                 minetest.record_protection_violation(pos, player_name)
 543                 return itemstack
 544         end
 545         -- Check tree volume for protection
 546         if minetest.is_area_protected(
 547                         vector.add(pos, minp_relative),
 548                         vector.add(pos, maxp_relative),
 549                         player_name,
 550                         interval) then
 551                 minetest.record_protection_violation(pos, player_name)
 552                 -- Print extra information to explain
 553                 minetest.chat_send_player(player_name, "Tree will intersect protection")
 554                 return itemstack
 555         end
 556
 557         minetest.log("action", player_name .. " places node "
 558                         .. sapling_name .. " at " .. minetest.pos_to_string(pos))
 559
 560         local take_item = not (creative and creative.is_enabled_for
 561                 and creative.is_enabled_for(player_name))
 562         local newnode = {name = sapling_name}
 563         local ndef = minetest.registered_nodes[sapling_name]
 564         minetest.set_node(pos, newnode)
 565
 566         -- Run callback
 567         if ndef and ndef.after_place_node then
 568                 -- Deepcopy place_to and pointed_thing because callback can modify it
 569                 if ndef.after_place_node(table.copy(pos), placer,
 570                                 itemstack, table.copy(pointed_thing)) then
 571                         take_item = false
 572                 end
 573         end
 574
 575         -- Run script hook
 576         for _, callback in ipairs(minetest.registered_on_placenodes) do
 577                 -- Deepcopy pos, node and pointed_thing because callback can modify them
 578                 if callback(table.copy(pos), table.copy(newnode),
 579                                 placer, table.copy(node or {}),
 580                                 itemstack, table.copy(pointed_thing)) then
 581                         take_item = false
 582                 end
 583         end
 584
 585         if take_item then
 586                 itemstack:take_item()
 587         end
 588
 589         return itemstack
 590 end