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