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