1769 lines
63 KiB
Lua
1769 lines
63 KiB
Lua
-- Jungletree mod by Bas080.
|
|
-- License WTFPL.
|
|
|
|
-- Forked by paramat.
|
|
-- Perlin Jungletrees Ongen 0.1.0.
|
|
-- License WTFPL as before, see license.txt file.
|
|
|
|
-- Deleted habitat mod.
|
|
-- Only find ground level in randomly chosen columns within biome.
|
|
-- Only check for grass away from trunks when altitude <= MAXALT.
|
|
-- Increased roots depth to 2 or 5 nodes.
|
|
-- Fixed bug "if height <= 0 then" line 131.
|
|
-- Jungletree function defined and spawn jungletrees on generated chunk.
|
|
-- Deleted laggy "find_node_near" functions with large radius that checked for water and sand, now only check trunk spacing.
|
|
-- Added debug messages option.
|
|
-- Added remove default trees option.
|
|
-- Perlin matched to snow biomes perlin(112, 3, 0.5, 150) to keep jungle away from snow biomes.
|
|
-- Noise range for more biome shapes.
|
|
-- Added abm to grow saplings into jungletrees.
|
|
-- ONGEN option.
|
|
-- Variables MINSPA and MAXSPA to control denstity at centre and edge.
|
|
-- More red and yellow leaves.
|
|
|
|
local MAXALT = 23 -- 23 -- Maximum altitude.
|
|
local MINSPA = 2 -- 2 -- Minimum spacing to other trunks or roots in deep jungle.
|
|
local MAXSPA = 11 -- 11 -- Average spacing to other trunks or roots at jungle edge.
|
|
local NORMPLANT = 16
|
|
|
|
-- Snowy perlin. Should match your snow biomes mod perlin.
|
|
local SEEDDIFF = 112 -- 112 -- World specific perlin seed = world seed + seeddiff.
|
|
local OCTAVES = 3 -- 3 -- Each higher octave adds variation on a scale half as big.
|
|
local PERSISTENCE = 0.5 -- 0.5 -- Relative amplitude of each higher octave.
|
|
local SCALE = 150 -- 150 -- Scale of largest pattern variation.
|
|
|
|
local NOISEH = -0.6 -- -0.6 ]
|
|
local NOISEL = -1.2 -- -1.2 ] Noise range for jungle biome. Negative values keep jungle away from snow biomes. Snow biomes when noise > 0.53.
|
|
|
|
local SAPLING_ABM_INTERVAL = 23 -- 23
|
|
local SAPLING_ABM_CHANCE = 13 -- 13
|
|
|
|
local ONGEN = true -- Spawn jungletrees on generated chunk? (true / false).
|
|
local REMOVE_TREES = true -- Remove default trees on generated chunk in jungle biomes?
|
|
local DEBUG = true
|
|
|
|
local colchamin = MINSPA ^ 2
|
|
local factor = (MAXSPA ^ 2 - colchamin) * 4
|
|
local nav = (NOISEH + NOISEL) / 2
|
|
local nra = NOISEH - NOISEL
|
|
|
|
if ONGEN then
|
|
minetest.register_on_generated(function(minp, maxp, seed)
|
|
-- If generated chunk is a surface chunk
|
|
if minp.y == -32 then
|
|
-- Define perlin noise, co-ords of min and max points, chunk dimensions.
|
|
local perlin = minetest.env:get_perlin(SEEDDIFF, OCTAVES, PERSISTENCE, SCALE)
|
|
local x0 = minp.x
|
|
local z0 = minp.z
|
|
local x1 = maxp.x
|
|
local z1 = maxp.z
|
|
local xl = x1 - x0
|
|
local zl = z1 - z0
|
|
-- Speed hack: checks 9 points in chunk for conifer biome.
|
|
if not (perlin:get2d({x=x0, y=z0}) > NOISEL and perlin:get2d({x=x0, y=z0}) < NOISEH)
|
|
and not (perlin:get2d({x=x0, y=z1}) > NOISEL and perlin:get2d({x=x0, y=z1}) < NOISEH)
|
|
and not (perlin:get2d({x=x1, y=z0}) > NOISEL and perlin:get2d({x=x1, y=z0}) < NOISEH)
|
|
and not (perlin:get2d({x=x1, y=z1}) > NOISEL and perlin:get2d({x=x1, y=z1}) < NOISEH)
|
|
and not (perlin:get2d({x=x0, y=z0+(zl/2)}) > NOISEL and perlin:get2d({x=x0, y=z0+(zl/2)}) < NOISEH)
|
|
and not (perlin:get2d({x=x1, y=z0+(zl/2)}) > NOISEL and perlin:get2d({x=x1, y=z0+(zl/2)}) < NOISEH)
|
|
and not (perlin:get2d({x=x0+(xl/2), y=z0}) > NOISEL and perlin:get2d({x=x0+(xl/2), y=z0}) < NOISEH)
|
|
and not (perlin:get2d({x=x0+(xl/2), y=z1}) > NOISEL and perlin:get2d({x=x0+(xl/2), y=z1}) < NOISEH)
|
|
and not (perlin:get2d({x=x0+(xl/2), y=z0+(zl/2)}) > NOISEL and perlin:get2d({x=x0+(xl/2), y=z0+(zl/2)}) < NOISEH) then
|
|
return
|
|
end
|
|
|
|
if REMOVE_TREES == true then
|
|
-- Remove default trees in chunk.
|
|
local trees = minetest.env:find_nodes_in_area(minp, maxp, {"default:leaves","default:tree","default:apple"})
|
|
for i,v in pairs(trees) do
|
|
minetest.env:remove_node(v)
|
|
end
|
|
if DEBUG then
|
|
print ("[jungletree] Trees removed ("..minp.x.." "..minp.y.." "..minp.z..")")
|
|
end
|
|
end
|
|
-- Loop through all columns in chunk, for each column do.
|
|
for i = 0, xl do
|
|
for j = 0, zl do
|
|
local x = x0 + i
|
|
local z = z0 + j
|
|
local noise = perlin:get2d({x = x, y = z})
|
|
if noise > NOISEL and noise < NOISEH then
|
|
-- Calculate column chance for varying tree density.
|
|
local colcha = colchamin + math.floor(factor * (math.abs(noise - nav) / nra) ^ 2)
|
|
if math.random(1,colcha) == 1 then
|
|
-- Find ground level y.
|
|
local ground_y = nil
|
|
for y=maxp.y,minp.y,-1 do
|
|
local nodename = minetest.env:get_node({x=x,y=y,z=z}).name
|
|
if nodename ~= "air" and nodename ~= "default:water_source" then
|
|
ground_y = y
|
|
break
|
|
end
|
|
end
|
|
-- Check if ground, check altitude
|
|
if ground_y and ground_y <= MAXALT then
|
|
-- Check for grass, check trunk spacing
|
|
local nodename = minetest.env:get_node({x=x,y=ground_y,z=z}).name
|
|
local junnear = minetest.env:find_node_near({x=x,y=ground_y,z=z}, MINSPA, "default:jungletree")
|
|
local defnear = minetest.env:find_node_near({x=x,y=ground_y,z=z}, MINSPA, "default:tree")
|
|
if nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 16 then
|
|
glowtest_sgreentree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 2 then
|
|
glowtest_mgreentree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 3 then
|
|
glowtest_lgreentree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 4 then
|
|
glowtest_sbluetree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 5 then
|
|
glowtest_mbluetree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 6 then
|
|
glowtest_lbluetree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 7 then
|
|
glowtest_spinktree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 8 then
|
|
glowtest_mpinktree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 9 then
|
|
glowtest_lpinktree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 10 then
|
|
glowtest_syellowtree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 11 then
|
|
glowtest_myellowtree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 12 then
|
|
glowtest_lyellowtree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 13 then
|
|
glowtest_swhitetree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 14 then
|
|
glowtest_mwhitetree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:dirt_with_grass" and junnear == nil and defnear == nil and math.random(NORMPLANT) == 15 then
|
|
glowtest_lwhitetree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:desert_sand" and math.random(NORMPLANT) == 16 then
|
|
glowtest_sredtree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:desert_sand" and math.random(NORMPLANT) == 2 then
|
|
glowtest_mredtree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:desert_sand" and math.random(NORMPLANT) == 3 then
|
|
glowtest_lredtree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:desert_sand" and math.random(NORMPLANT) == 4 then
|
|
glowtest_sblacktree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:desert_sand" and math.random(NORMPLANT) == 5 then
|
|
glowtest_mblacktree({x=x,y=ground_y+1,z=z})
|
|
elseif nodename == "default:desert_sand" and math.random(NORMPLANT) == 6 then
|
|
glowtest_lblacktree({x=x,y=ground_y+1,z=z})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
|
|
minetest.register_node("glowtest:tree", {
|
|
description = "Glowing Tree",
|
|
tiles = {"default_tree_top.png", "default_tree_top.png", "default_tree.png"},
|
|
paramtype2 = "facedir",
|
|
light_source = 8,
|
|
groups = {tree=1,choppy=2,oddly_breakable_by_hand=1,flammable=2},
|
|
sounds = default.node_sound_wood_defaults(),
|
|
drop = "default:tree",
|
|
on_place = minetest.rotate_node
|
|
})
|
|
|
|
minetest.register_node("glowtest:stonetree", {
|
|
description = "Glowing Stone Tree",
|
|
tiles = {"default_stone.png"},
|
|
paramtype2 = "facedir",
|
|
light_source = 8,
|
|
groups = {tree=1,cracky=3},
|
|
sounds = default.node_sound_wood_defaults(),
|
|
drop = "default:stone",
|
|
on_place = minetest.rotate_node
|
|
})
|
|
|
|
minetest.register_node("glowtest:blueleaf", {
|
|
description = "Glowing Blue Leaf",
|
|
drawtype = "allfaces_optional",
|
|
visual_scale = 1.3,
|
|
tiles = {"glowtest_blueleaf.png"},
|
|
paramtype = "light",
|
|
light_source = 8,
|
|
groups = {snappy=3, leafdecay=3, flammable=2, leaves=1},
|
|
drop = {
|
|
max_items = 1,
|
|
items = {
|
|
{ items = {'glowtest:sbluesapling'}, rarity = 20},
|
|
{ items = {'glowtest:mbluesapling'}, rarity = 40},
|
|
{ items = {'glowtest:lbluesapling'}, rarity = 60},
|
|
{ items = {'glowtest:blueleaf'} }
|
|
}
|
|
},
|
|
sounds = default.node_sound_leaves_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:redleaf", {
|
|
description = "Glowing Blood Leaf",
|
|
drawtype = "allfaces_optional",
|
|
visual_scale = 1.3,
|
|
tiles = {"glowtest_redleaf.png"},
|
|
paramtype = "light",
|
|
light_source = 8,
|
|
groups = {snappy=3, leafdecay=3, flammable=2, leaves=1},
|
|
drop = {
|
|
max_items = 1,
|
|
items = {
|
|
{ items = {'glowtest:sredsapling'}, rarity = 20},
|
|
{ items = {'glowtest:mredsapling'}, rarity = 40},
|
|
{ items = {'glowtest:lredsapling'}, rarity = 60},
|
|
{ items = {'glowtest:redleaf'} }
|
|
}
|
|
},
|
|
sounds = default.node_sound_leaves_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:blackleaf", {
|
|
description = "Glowing Cursed Leaf",
|
|
drawtype = "allfaces_optional",
|
|
visual_scale = 1.3,
|
|
tiles = {"glowtest_blackleaf.png"},
|
|
paramtype = "light",
|
|
light_source = 8,
|
|
groups = {snappy=3, leafdecay=3, flammable=2, leaves=1},
|
|
drop = {
|
|
max_items = 1,
|
|
items = {
|
|
{ items = {'glowtest:sblacksapling'}, rarity = 20},
|
|
{ items = {'glowtest:mblacksapling'}, rarity = 40},
|
|
{ items = {'glowtest:lblacksapling'}, rarity = 60},
|
|
{ items = {'glowtest:blackleaf'} }
|
|
}
|
|
},
|
|
sounds = default.node_sound_leaves_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:pinkleaf", {
|
|
description = "Glowing Pink Leaf",
|
|
drawtype = "allfaces_optional",
|
|
visual_scale = 1.3,
|
|
tiles = {"glowtest_pinkleaf.png"},
|
|
paramtype = "light",
|
|
light_source = 8,
|
|
groups = {snappy=3, leafdecay=3, flammable=2, leaves=1},
|
|
drop = {
|
|
max_items = 1,
|
|
items = {
|
|
{ items = {'glowtest:spinksapling'}, rarity = 20},
|
|
{ items = {'glowtest:mpinksapling'}, rarity = 40},
|
|
{ items = {'glowtest:lpinksapling'}, rarity = 60},
|
|
{ items = {'glowtest:pinkleaf'} }
|
|
}
|
|
},
|
|
sounds = default.node_sound_leaves_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:yellowleaf", {
|
|
description = "Glowing Yellow Leaf",
|
|
drawtype = "allfaces_optional",
|
|
visual_scale = 1.3,
|
|
tiles = {"glowtest_yellowleaf.png"},
|
|
paramtype = "light",
|
|
light_source = 8,
|
|
groups = {snappy=3, leafdecay=3, flammable=2, leaves=1},
|
|
drop = {
|
|
max_items = 1,
|
|
items = {
|
|
{ items = {'glowtest:syellowsapling'}, rarity = 20},
|
|
{ items = {'glowtest:myellowsapling'}, rarity = 40},
|
|
{ items = {'glowtest:lyellowsapling'}, rarity = 60},
|
|
{ items = {'glowtest:yellowleaf'} }
|
|
}
|
|
},
|
|
sounds = default.node_sound_leaves_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:greenleaf", {
|
|
description = "Glowing Green Leaf",
|
|
drawtype = "allfaces_optional",
|
|
visual_scale = 1.3,
|
|
tiles = {"glowtest_greenleaf.png"},
|
|
paramtype = "light",
|
|
light_source = 8,
|
|
groups = {snappy=3, leafdecay=3, flammable=2, leaves=1},
|
|
drop = {
|
|
max_items = 1,
|
|
items = {
|
|
{ items = {'glowtest:sgreensapling'}, rarity = 20},
|
|
{ items = {'glowtest:mgreensapling'}, rarity = 40},
|
|
{ items = {'glowtest:lgreensapling'}, rarity = 60},
|
|
{ items = {'glowtest:greenleaf'} }
|
|
}
|
|
},
|
|
sounds = default.node_sound_leaves_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:whiteleaf", {
|
|
description = "Glowing White Leaf",
|
|
drawtype = "allfaces_optional",
|
|
visual_scale = 1.3,
|
|
tiles = {"glowtest_whiteleaf.png"},
|
|
paramtype = "light",
|
|
light_source = 8,
|
|
groups = {snappy=3, leafdecay=3, flammable=2, leaves=1},
|
|
drop = {
|
|
max_items = 1,
|
|
items = {
|
|
{ items = {'glowtest:swhitesapling'}, rarity = 20},
|
|
{ items = {'glowtest:mwhitesapling'}, rarity = 40},
|
|
{ items = {'glowtest:lwhitesapling'}, rarity = 60},
|
|
{ items = {'glowtest:whiteleaf'} }
|
|
}
|
|
},
|
|
sounds = default.node_sound_leaves_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:glow_ore", {
|
|
description = "Limestone Ore",
|
|
tiles = {"default_dirt.png^glowtest_glow_ore.png"},
|
|
is_ground_content = true,
|
|
light_source = 4,
|
|
groups = {cracky=3},
|
|
drop = {
|
|
max_items = 2,
|
|
items = {
|
|
{ items = {'glowtest:sgreensapling'}, rarity = 20},
|
|
{ items = {'glowtest:mgreensapling'}, rarity = 40},
|
|
{ items = {'glowtest:lgreensapling'}, rarity = 60},
|
|
{ items = {'glowtest:sbluesapling'}, rarity = 20},
|
|
{ items = {'glowtest:mbluesapling'}, rarity = 40},
|
|
{ items = {'glowtest:lbluesapling'}, rarity = 60},
|
|
{ items = {'glowtest:spinksapling'}, rarity = 20},
|
|
{ items = {'glowtest:mpinksapling'}, rarity = 40},
|
|
{ items = {'glowtest:lpinksapling'}, rarity = 60},
|
|
{ items = {'glowtest:syellowsapling'}, rarity = 20},
|
|
{ items = {'glowtest:myellowsapling'}, rarity = 40},
|
|
{ items = {'glowtest:lyellowsapling'}, rarity = 60},
|
|
{ items = {'glowtest:swhitesapling'}, rarity = 20},
|
|
{ items = {'glowtest:mwhitesapling'}, rarity = 40},
|
|
{ items = {'glowtest:lwhitesapling'}, rarity = 60},
|
|
{ items = {'glowtest:glowlump'} }
|
|
}
|
|
},
|
|
sounds = default.node_sound_stone_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:glow_ore_cursed", {
|
|
description = "Limestone Ore",
|
|
tiles = {"default_desert_stone.png^glowtest_cursed_glow_ore.png"},
|
|
is_ground_content = true,
|
|
light_source = 4,
|
|
groups = {cracky=3},
|
|
drop = {
|
|
max_items = 2,
|
|
items = {
|
|
{ items = {'glowtest:sblacksapling'}, rarity = 20},
|
|
{ items = {'glowtest:mblacksapling'}, rarity = 40},
|
|
{ items = {'glowtest:lblacksapling'}, rarity = 60},
|
|
{ items = {'glowtest:sredsapling'}, rarity = 20},
|
|
{ items = {'glowtest:mredsapling'}, rarity = 40},
|
|
{ items = {'glowtest:lredsapling'}, rarity = 60},
|
|
{ items = {'glowtest:glowlump_cursed'} }
|
|
}
|
|
},
|
|
sounds = default.node_sound_stone_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:sgreensapling", {
|
|
description = "Small Green Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 0.7,
|
|
tiles = {"glowtest_greensapling.png"},
|
|
inventory_image = "glowtest_greensapling.png",
|
|
wield_image = "glowtest_greensapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
selection_box = {
|
|
type = "fixed",
|
|
fixed = { -0.15, -0.5, -0.15, 0.15, 0.2, 0.15 },
|
|
},
|
|
})
|
|
|
|
minetest.register_node("glowtest:mgreensapling", {
|
|
description = "Medium Green Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 1.0,
|
|
tiles = {"glowtest_greensapling.png"},
|
|
inventory_image = "glowtest_greensapling.png",
|
|
wield_image = "glowtest_greensapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:lgreensapling", {
|
|
description = "Large Green Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 2.0,
|
|
tiles = {"glowtest_greensapling.png"},
|
|
inventory_image = "glowtest_greensapling.png",
|
|
wield_image = "glowtest_greensapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:sbluesapling", {
|
|
description = "Small Blue Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 0.7,
|
|
tiles = {"glowtest_bluesapling.png"},
|
|
inventory_image = "glowtest_bluesapling.png",
|
|
wield_image = "glowtest_bluesapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
selection_box = {
|
|
type = "fixed",
|
|
fixed = { -0.15, -0.5, -0.15, 0.15, 0.2, 0.15 },
|
|
},
|
|
})
|
|
|
|
minetest.register_node("glowtest:mbluesapling", {
|
|
description = "Medium Blue Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 1.0,
|
|
tiles = {"glowtest_bluesapling.png"},
|
|
inventory_image = "glowtest_bluesapling.png",
|
|
wield_image = "glowtest_bluesapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:lbluesapling", {
|
|
description = "Large Blue Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 2.0,
|
|
tiles = {"glowtest_bluesapling.png"},
|
|
inventory_image = "glowtest_bluesapling.png",
|
|
wield_image = "glowtest_bluesapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:spinksapling", {
|
|
description = "Small Pink Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 0.7,
|
|
tiles = {"glowtest_pinksapling.png"},
|
|
inventory_image = "glowtest_pinksapling.png",
|
|
wield_image = "glowtest_pinksapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
selection_box = {
|
|
type = "fixed",
|
|
fixed = { -0.15, -0.5, -0.15, 0.15, 0.2, 0.15 },
|
|
},
|
|
})
|
|
|
|
minetest.register_node("glowtest:mpinksapling", {
|
|
description = "Medium Pink Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 1.0,
|
|
tiles = {"glowtest_pinksapling.png"},
|
|
inventory_image = "glowtest_pinksapling.png",
|
|
wield_image = "glowtest_pinksapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:lpinksapling", {
|
|
description = "Large Pink Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 2.0,
|
|
tiles = {"glowtest_pinksapling.png"},
|
|
inventory_image = "glowtest_pinksapling.png",
|
|
wield_image = "glowtest_pinksapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:syellowsapling", {
|
|
description = "Small Yellow Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 0.7,
|
|
tiles = {"glowtest_yellowsapling.png"},
|
|
inventory_image = "glowtest_yellowsapling.png",
|
|
wield_image = "glowtest_yellowsapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
selection_box = {
|
|
type = "fixed",
|
|
fixed = { -0.15, -0.5, -0.15, 0.15, 0.2, 0.15 },
|
|
},
|
|
})
|
|
|
|
minetest.register_node("glowtest:myellowsapling", {
|
|
description = "Medium Yellow Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 1.0,
|
|
tiles = {"glowtest_yellowsapling.png"},
|
|
inventory_image = "glowtest_yellowsapling.png",
|
|
wield_image = "glowtest_yellowsapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:lyellowsapling", {
|
|
description = "Large Yellow Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 2.0,
|
|
tiles = {"glowtest_yellowsapling.png"},
|
|
inventory_image = "glowtest_yellowsapling.png",
|
|
wield_image = "glowtest_yellowsapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:sredsapling", {
|
|
description = "Small Blood Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 0.7,
|
|
tiles = {"glowtest_redsapling.png"},
|
|
inventory_image = "glowtest_redsapling.png",
|
|
wield_image = "glowtest_redsapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
selection_box = {
|
|
type = "fixed",
|
|
fixed = { -0.15, -0.5, -0.15, 0.15, 0.2, 0.15 },
|
|
},
|
|
})
|
|
|
|
minetest.register_node("glowtest:mredsapling", {
|
|
description = "Medium Blood Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 1.0,
|
|
tiles = {"glowtest_redsapling.png"},
|
|
inventory_image = "glowtest_redsapling.png",
|
|
wield_image = "glowtest_redsapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:lredsapling", {
|
|
description = "Large Blood Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 2.0,
|
|
tiles = {"glowtest_redsapling.png"},
|
|
inventory_image = "glowtest_redsapling.png",
|
|
wield_image = "glowtest_redsapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:swhitesapling", {
|
|
description = "Small White Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 0.7,
|
|
tiles = {"glowtest_whitesapling.png"},
|
|
inventory_image = "glowtest_whitesapling.png",
|
|
wield_image = "glowtest_whitesapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
selection_box = {
|
|
type = "fixed",
|
|
fixed = { -0.15, -0.5, -0.15, 0.15, 0.2, 0.15 },
|
|
},
|
|
})
|
|
|
|
minetest.register_node("glowtest:mwhitesapling", {
|
|
description = "Medium White Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 1.0,
|
|
tiles = {"glowtest_whitesapling.png"},
|
|
inventory_image = "glowtest_whitesapling.png",
|
|
wield_image = "glowtest_whitesapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:lwhitesapling", {
|
|
description = "Large White Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 2.0,
|
|
tiles = {"glowtest_whitesapling.png"},
|
|
inventory_image = "glowtest_whitesapling.png",
|
|
wield_image = "glowtest_whitesapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:rune_1", {
|
|
description = "Wyvern's Soul Rune",
|
|
tiles = {"default_stone.png^glowtest_rune_1.png"},
|
|
is_ground_content = true,
|
|
light_source = 14,
|
|
groups = {cracky=3},
|
|
sounds = default.node_sound_stone_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:rune_2", {
|
|
description = "Eye Rune",
|
|
tiles = {"default_stone.png^glowtest_rune_2.png"},
|
|
is_ground_content = true,
|
|
light_source = 14,
|
|
groups = {cracky=3},
|
|
sounds = default.node_sound_stone_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:sblacksapling", {
|
|
description = "Small Cursed Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 0.7,
|
|
tiles = {"glowtest_blacksapling.png"},
|
|
inventory_image = "glowtest_blacksapling.png",
|
|
wield_image = "glowtest_blacksapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:mblacksapling", {
|
|
description = "Medium Cursed Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 1.0,
|
|
tiles = {"glowtest_blacksapling.png"},
|
|
inventory_image = "glowtest_blacksapling.png",
|
|
wield_image = "glowtest_blacksapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
minetest.register_node("glowtest:lblacksapling", {
|
|
description = "Large Cursed Sapling",
|
|
drawtype = "plantlike",
|
|
visual_scale = 2.0,
|
|
tiles = {"glowtest_blacksapling.png"},
|
|
inventory_image = "glowtest_blacksapling.png",
|
|
wield_image = "glowtest_blacksapling.png",
|
|
paramtype = "light",
|
|
walkable = false,
|
|
light_source = 8,
|
|
groups = {snappy=2,dig_immediate=3,flammable=2},
|
|
sounds = default.node_sound_defaults(),
|
|
})
|
|
|
|
-- TREE FUNCTIONS
|
|
|
|
-- Green
|
|
|
|
function glowtest_sgreentree(pos)
|
|
local t = 3 + math.random(2) -- trunk height
|
|
for j = -2, t do
|
|
if j == t or j == t - 2 then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:greenleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:tree"})
|
|
end
|
|
end
|
|
|
|
function glowtest_mgreentree(pos)
|
|
local t = 6 + math.random(4) -- trunk height
|
|
for j = -3, t do
|
|
if j == math.floor(t * 0.7) or j == t then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:greenleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:tree"})
|
|
end
|
|
end
|
|
|
|
function add_tree_branch_green(pos)
|
|
minetest.env:add_node(pos, {name="glowtest:tree"})
|
|
for i = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
for k = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
local p = {x=pos.x+i, y=pos.y, z=pos.z+k}
|
|
local n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:greenleaf"})
|
|
end
|
|
local chance = math.abs(i+k)
|
|
if (chance < 1) then
|
|
p = {x=pos.x+i, y=pos.y+1, z=pos.z+k}
|
|
n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:greenleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function glowtest_lgreentree(pos)
|
|
local height = 10 + math.random(5)
|
|
if height < 10 then
|
|
for i = height, -2, -1 do
|
|
local p = {x=pos.x, y=pos.y+i, z=pos.z}
|
|
minetest.env:add_node(p, {name="glowtest:tree"})
|
|
if i == height then
|
|
add_tree_branch_green({x=pos.x, y=pos.y+height+math.random(0, 1), z=pos.z})
|
|
add_tree_branch_green({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_green({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_green({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1})
|
|
add_tree_branch_green({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1})
|
|
end
|
|
if i < 0 then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1}, {name="glowtest:tree"})
|
|
end
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_green(branch_pos)
|
|
end
|
|
end
|
|
else
|
|
for i = height, -5, -1 do
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_green(branch_pos)
|
|
end
|
|
if i < math.random(0,1) then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z+1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x+2, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-2}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
end
|
|
if i == height then
|
|
add_tree_branch_green({x=pos.x+1, y=pos.y+i, z=pos.z+1})
|
|
add_tree_branch_green({x=pos.x+2, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_green({x=pos.x, y=pos.y+i, z=pos.z-2})
|
|
add_tree_branch_green({x=pos.x-1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_green({x=pos.x+1, y=pos.y+i, z=pos.z+2})
|
|
add_tree_branch_green({x=pos.x+3, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_green({x=pos.x, y=pos.y+i, z=pos.z-3})
|
|
add_tree_branch_green({x=pos.x-2, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_green({x=pos.x+1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_green({x=pos.x+1, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_green({x=pos.x, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_green({x=pos.x, y=pos.y+i, z=pos.z})
|
|
else
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Blue
|
|
|
|
function glowtest_sbluetree(pos)
|
|
local t = 3 + math.random(2) -- trunk height
|
|
for j = -2, t do
|
|
if j == t or j == t - 2 then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:blueleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:tree"})
|
|
end
|
|
end
|
|
|
|
function glowtest_mbluetree(pos)
|
|
local t = 6 + math.random(4) -- trunk height
|
|
for j = -3, t do
|
|
if j == math.floor(t * 0.7) or j == t then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:blueleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:tree"})
|
|
end
|
|
end
|
|
|
|
function add_tree_branch_blue(pos)
|
|
minetest.env:add_node(pos, {name="glowtest:tree"})
|
|
for i = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
for k = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
local p = {x=pos.x+i, y=pos.y, z=pos.z+k}
|
|
local n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:blueleaf"})
|
|
end
|
|
local chance = math.abs(i+k)
|
|
if (chance < 1) then
|
|
p = {x=pos.x+i, y=pos.y+1, z=pos.z+k}
|
|
n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:blueleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function glowtest_lbluetree(pos)
|
|
local height = 10 + math.random(5)
|
|
if height < 10 then
|
|
for i = height, -2, -1 do
|
|
local p = {x=pos.x, y=pos.y+i, z=pos.z}
|
|
minetest.env:add_node(p, {name="glowtest:tree"})
|
|
if i == height then
|
|
add_tree_branch_blue({x=pos.x, y=pos.y+height+math.random(0, 1), z=pos.z})
|
|
add_tree_branch_blue({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_blue({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_blue({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1})
|
|
add_tree_branch_blue({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1})
|
|
end
|
|
if i < 0 then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1}, {name="glowtest:tree"})
|
|
end
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_blue(branch_pos)
|
|
end
|
|
end
|
|
else
|
|
for i = height, -5, -1 do
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_blue(branch_pos)
|
|
end
|
|
if i < math.random(0,1) then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z+1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x+2, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-2}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
end
|
|
if i == height then
|
|
add_tree_branch_blue({x=pos.x+1, y=pos.y+i, z=pos.z+1})
|
|
add_tree_branch_blue({x=pos.x+2, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_blue({x=pos.x, y=pos.y+i, z=pos.z-2})
|
|
add_tree_branch_blue({x=pos.x-1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_blue({x=pos.x+1, y=pos.y+i, z=pos.z+2})
|
|
add_tree_branch_blue({x=pos.x+3, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_blue({x=pos.x, y=pos.y+i, z=pos.z-3})
|
|
add_tree_branch_blue({x=pos.x-2, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_blue({x=pos.x+1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_blue({x=pos.x+1, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_blue({x=pos.x, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_blue({x=pos.x, y=pos.y+i, z=pos.z})
|
|
else
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Pink
|
|
|
|
function glowtest_spinktree(pos)
|
|
local t = 3 + math.random(2) -- trunk height
|
|
for j = -2, t do
|
|
if j == t or j == t - 2 then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:pinkleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:tree"})
|
|
end
|
|
end
|
|
|
|
function glowtest_mpinktree(pos)
|
|
local t = 6 + math.random(4) -- trunk height
|
|
for j = -3, t do
|
|
if j == math.floor(t * 0.7) or j == t then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:pinkleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:tree"})
|
|
end
|
|
end
|
|
|
|
function add_tree_branch_pink(pos)
|
|
minetest.env:add_node(pos, {name="glowtest:tree"})
|
|
for i = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
for k = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
local p = {x=pos.x+i, y=pos.y, z=pos.z+k}
|
|
local n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:pinkleaf"})
|
|
end
|
|
local chance = math.abs(i+k)
|
|
if (chance < 1) then
|
|
p = {x=pos.x+i, y=pos.y+1, z=pos.z+k}
|
|
n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:pinkleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function glowtest_lpinktree(pos)
|
|
local height = 10 + math.random(5)
|
|
if height < 10 then
|
|
for i = height, -2, -1 do
|
|
local p = {x=pos.x, y=pos.y+i, z=pos.z}
|
|
minetest.env:add_node(p, {name="glowtest:tree"})
|
|
if i == height then
|
|
add_tree_branch_pink({x=pos.x, y=pos.y+height+math.random(0, 1), z=pos.z})
|
|
add_tree_branch_pink({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_pink({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_pink({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1})
|
|
add_tree_branch_pink({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1})
|
|
end
|
|
if i < 0 then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1}, {name="glowtest:tree"})
|
|
end
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_pink(branch_pos)
|
|
end
|
|
end
|
|
else
|
|
for i = height, -5, -1 do
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_pink(branch_pos)
|
|
end
|
|
if i < math.random(0,1) then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z+1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x+2, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-2}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
end
|
|
if i == height then
|
|
add_tree_branch_pink({x=pos.x+1, y=pos.y+i, z=pos.z+1})
|
|
add_tree_branch_pink({x=pos.x+2, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_pink({x=pos.x, y=pos.y+i, z=pos.z-2})
|
|
add_tree_branch_pink({x=pos.x-1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_pink({x=pos.x+1, y=pos.y+i, z=pos.z+2})
|
|
add_tree_branch_pink({x=pos.x+3, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_pink({x=pos.x, y=pos.y+i, z=pos.z-3})
|
|
add_tree_branch_pink({x=pos.x-2, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_pink({x=pos.x+1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_pink({x=pos.x+1, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_pink({x=pos.x, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_pink({x=pos.x, y=pos.y+i, z=pos.z})
|
|
else
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Yellow
|
|
|
|
function glowtest_syellowtree(pos)
|
|
local t = 3 + math.random(2) -- trunk height
|
|
for j = -2, t do
|
|
if j == t or j == t - 2 then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:yellowleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:tree"})
|
|
end
|
|
end
|
|
|
|
function glowtest_myellowtree(pos)
|
|
local t = 6 + math.random(4) -- trunk height
|
|
for j = -3, t do
|
|
if j == math.floor(t * 0.7) or j == t then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:yellowleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:tree"})
|
|
end
|
|
end
|
|
|
|
function add_tree_branch_yellow(pos)
|
|
minetest.env:add_node(pos, {name="glowtest:tree"})
|
|
for i = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
for k = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
local p = {x=pos.x+i, y=pos.y, z=pos.z+k}
|
|
local n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:yellowleaf"})
|
|
end
|
|
local chance = math.abs(i+k)
|
|
if (chance < 1) then
|
|
p = {x=pos.x+i, y=pos.y+1, z=pos.z+k}
|
|
n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:yellowleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function glowtest_lyellowtree(pos)
|
|
local height = 10 + math.random(5)
|
|
if height < 10 then
|
|
for i = height, -2, -1 do
|
|
local p = {x=pos.x, y=pos.y+i, z=pos.z}
|
|
minetest.env:add_node(p, {name="glowtest:tree"})
|
|
if i == height then
|
|
add_tree_branch_yellow({x=pos.x, y=pos.y+height+math.random(0, 1), z=pos.z})
|
|
add_tree_branch_yellow({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_yellow({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_yellow({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1})
|
|
add_tree_branch_yellow({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1})
|
|
end
|
|
if i < 0 then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1}, {name="glowtest:tree"})
|
|
end
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_yellow(branch_pos)
|
|
end
|
|
end
|
|
else
|
|
for i = height, -5, -1 do
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_yellow(branch_pos)
|
|
end
|
|
if i < math.random(0,1) then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z+1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x+2, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-2}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
end
|
|
if i == height then
|
|
add_tree_branch_yellow({x=pos.x+1, y=pos.y+i, z=pos.z+1})
|
|
add_tree_branch_yellow({x=pos.x+2, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_yellow({x=pos.x, y=pos.y+i, z=pos.z-2})
|
|
add_tree_branch_yellow({x=pos.x-1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_yellow({x=pos.x+1, y=pos.y+i, z=pos.z+2})
|
|
add_tree_branch_yellow({x=pos.x+3, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_yellow({x=pos.x, y=pos.y+i, z=pos.z-3})
|
|
add_tree_branch_yellow({x=pos.x-2, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_yellow({x=pos.x+1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_yellow({x=pos.x+1, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_yellow({x=pos.x, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_yellow({x=pos.x, y=pos.y+i, z=pos.z})
|
|
else
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- White
|
|
|
|
function glowtest_swhitetree(pos)
|
|
local t = 3 + math.random(2) -- trunk height
|
|
for j = -2, t do
|
|
if j == t or j == t - 2 then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:whiteleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:tree"})
|
|
end
|
|
end
|
|
|
|
function glowtest_mwhitetree(pos)
|
|
local t = 6 + math.random(4) -- trunk height
|
|
for j = -3, t do
|
|
if j == math.floor(t * 0.7) or j == t then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:whiteleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:tree"})
|
|
end
|
|
end
|
|
|
|
function add_tree_branch_white(pos)
|
|
minetest.env:add_node(pos, {name="glowtest:tree"})
|
|
for i = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
for k = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
local p = {x=pos.x+i, y=pos.y, z=pos.z+k}
|
|
local n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:whiteleaf"})
|
|
end
|
|
local chance = math.abs(i+k)
|
|
if (chance < 1) then
|
|
p = {x=pos.x+i, y=pos.y+1, z=pos.z+k}
|
|
n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:whiteleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function glowtest_lwhitetree(pos)
|
|
local height = 10 + math.random(5)
|
|
if height < 10 then
|
|
for i = height, -2, -1 do
|
|
local p = {x=pos.x, y=pos.y+i, z=pos.z}
|
|
minetest.env:add_node(p, {name="glowtest:tree"})
|
|
if i == height then
|
|
add_tree_branch_white({x=pos.x, y=pos.y+height+math.random(0, 1), z=pos.z})
|
|
add_tree_branch_white({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_white({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_white({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1})
|
|
add_tree_branch_white({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1})
|
|
end
|
|
if i < 0 then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1}, {name="glowtest:tree"})
|
|
end
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_white(branch_pos)
|
|
end
|
|
end
|
|
else
|
|
for i = height, -5, -1 do
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_white(branch_pos)
|
|
end
|
|
if i < math.random(0,1) then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z+1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x+2, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-2}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
end
|
|
if i == height then
|
|
add_tree_branch_white({x=pos.x+1, y=pos.y+i, z=pos.z+1})
|
|
add_tree_branch_white({x=pos.x+2, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_white({x=pos.x, y=pos.y+i, z=pos.z-2})
|
|
add_tree_branch_white({x=pos.x-1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_white({x=pos.x+1, y=pos.y+i, z=pos.z+2})
|
|
add_tree_branch_white({x=pos.x+3, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_white({x=pos.x, y=pos.y+i, z=pos.z-3})
|
|
add_tree_branch_white({x=pos.x-2, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_white({x=pos.x+1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_white({x=pos.x+1, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_white({x=pos.x, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_white({x=pos.x, y=pos.y+i, z=pos.z})
|
|
else
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-1}, {name="glowtest:tree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z}, {name="glowtest:tree"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Red
|
|
|
|
function glowtest_sredtree(pos)
|
|
local t = 3 + math.random(2) -- trunk height
|
|
for j = -2, t do
|
|
if j == t or j == t - 2 then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:redleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:stonetree"})
|
|
end
|
|
end
|
|
|
|
function glowtest_mredtree(pos)
|
|
local t = 6 + math.random(4) -- trunk height
|
|
for j = -3, t do
|
|
if j == math.floor(t * 0.7) or j == t then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:redleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:stonetree"})
|
|
end
|
|
end
|
|
|
|
function add_tree_branch_red(pos)
|
|
minetest.env:add_node(pos, {name="glowtest:stonetree"})
|
|
for i = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
for k = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
local p = {x=pos.x+i, y=pos.y, z=pos.z+k}
|
|
local n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:redleaf"})
|
|
end
|
|
local chance = math.abs(i+k)
|
|
if (chance < 1) then
|
|
p = {x=pos.x+i, y=pos.y+1, z=pos.z+k}
|
|
n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:redleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function glowtest_lredtree(pos)
|
|
local height = 10 + math.random(5)
|
|
if height < 10 then
|
|
for i = height, -2, -1 do
|
|
local p = {x=pos.x, y=pos.y+i, z=pos.z}
|
|
minetest.env:add_node(p, {name="glowtest:stonetree"})
|
|
if i == height then
|
|
add_tree_branch_red({x=pos.x, y=pos.y+height+math.random(0, 1), z=pos.z})
|
|
add_tree_branch_red({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_red({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_red({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1})
|
|
add_tree_branch_red({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1})
|
|
end
|
|
if i < 0 then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1}, {name="glowtest:stonetree"})
|
|
end
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_red(branch_pos)
|
|
end
|
|
end
|
|
else
|
|
for i = height, -5, -1 do
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_red(branch_pos)
|
|
end
|
|
if i < math.random(0,1) then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z+1}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x+2, y=pos.y+i, z=pos.z-1}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-2}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i, z=pos.z}, {name="glowtest:stonetree"})
|
|
end
|
|
if i == height then
|
|
add_tree_branch_red({x=pos.x+1, y=pos.y+i, z=pos.z+1})
|
|
add_tree_branch_red({x=pos.x+2, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_red({x=pos.x, y=pos.y+i, z=pos.z-2})
|
|
add_tree_branch_red({x=pos.x-1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_red({x=pos.x+1, y=pos.y+i, z=pos.z+2})
|
|
add_tree_branch_red({x=pos.x+3, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_red({x=pos.x, y=pos.y+i, z=pos.z-3})
|
|
add_tree_branch_red({x=pos.x-2, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_red({x=pos.x+1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_red({x=pos.x+1, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_red({x=pos.x, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_red({x=pos.x, y=pos.y+i, z=pos.z})
|
|
else
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z-1}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-1}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z}, {name="glowtest:stonetree"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
--Black
|
|
|
|
function glowtest_sblacktree(pos)
|
|
local t = 3 + math.random(2) -- trunk height
|
|
for j = -2, t do
|
|
if j == t or j == t - 2 then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:blackleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:stonetree"})
|
|
end
|
|
end
|
|
|
|
function glowtest_mblacktree(pos)
|
|
local t = 6 + math.random(4) -- trunk height
|
|
for j = -3, t do
|
|
if j == math.floor(t * 0.7) or j == t then
|
|
for i = -2, 2 do
|
|
for k = -2, 2 do
|
|
local absi = math.abs(i)
|
|
local absk = math.abs(k)
|
|
if math.random() > (absi + absk) / 24 then
|
|
minetest.add_node({x=pos.x+i,y=pos.y+j+math.random(0, 1),z=pos.z+k},{name="glowtest:blackleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
minetest.add_node({x=pos.x,y=pos.y+j,z=pos.z},{name="glowtest:stonetree"})
|
|
end
|
|
end
|
|
|
|
function add_tree_branch_black(pos)
|
|
minetest.env:add_node(pos, {name="glowtest:stonetree"})
|
|
for i = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
for k = math.floor(math.random(2)), -math.floor(math.random(2)), -1 do
|
|
local p = {x=pos.x+i, y=pos.y, z=pos.z+k}
|
|
local n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:blackleaf"})
|
|
end
|
|
local chance = math.abs(i+k)
|
|
if (chance < 1) then
|
|
p = {x=pos.x+i, y=pos.y+1, z=pos.z+k}
|
|
n = minetest.env:get_node(p)
|
|
if (n.name=="air") then
|
|
minetest.env:add_node(p, {name="glowtest:blackleaf"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function glowtest_lblacktree(pos)
|
|
local height = 10 + math.random(5)
|
|
if height < 10 then
|
|
for i = height, -2, -1 do
|
|
local p = {x=pos.x, y=pos.y+i, z=pos.z}
|
|
minetest.env:add_node(p, {name="glowtest:stonetree"})
|
|
if i == height then
|
|
add_tree_branch_black({x=pos.x, y=pos.y+height+math.random(0, 1), z=pos.z})
|
|
add_tree_branch_black({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_black({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z})
|
|
add_tree_branch_black({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1})
|
|
add_tree_branch_black({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1})
|
|
end
|
|
if i < 0 then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z+1}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i-math.random(2), z=pos.z}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i-math.random(2), z=pos.z-1}, {name="glowtest:stonetree"})
|
|
end
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_black(branch_pos)
|
|
end
|
|
end
|
|
else
|
|
for i = height, -5, -1 do
|
|
if (math.sin(i/height*i) < 0.2 and i > 3 and math.random(0,2) < 1.5) then
|
|
branch_pos = {x=pos.x+math.random(0,1), y=pos.y+i, z=pos.z-math.random(0,1)}
|
|
add_tree_branch_black(branch_pos)
|
|
end
|
|
if i < math.random(0,1) then
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z+1}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x+2, y=pos.y+i, z=pos.z-1}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-2}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x-1, y=pos.y+i, z=pos.z}, {name="glowtest:stonetree"})
|
|
end
|
|
if i == height then
|
|
add_tree_branch_black({x=pos.x+1, y=pos.y+i, z=pos.z+1})
|
|
add_tree_branch_black({x=pos.x+2, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_black({x=pos.x, y=pos.y+i, z=pos.z-2})
|
|
add_tree_branch_black({x=pos.x-1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_black({x=pos.x+1, y=pos.y+i, z=pos.z+2})
|
|
add_tree_branch_black({x=pos.x+3, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_black({x=pos.x, y=pos.y+i, z=pos.z-3})
|
|
add_tree_branch_black({x=pos.x-2, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_black({x=pos.x+1, y=pos.y+i, z=pos.z})
|
|
add_tree_branch_black({x=pos.x+1, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_black({x=pos.x, y=pos.y+i, z=pos.z-1})
|
|
add_tree_branch_black({x=pos.x, y=pos.y+i, z=pos.z})
|
|
else
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x+1, y=pos.y+i, z=pos.z-1}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z-1}, {name="glowtest:stonetree"})
|
|
minetest.env:add_node({x=pos.x, y=pos.y+i, z=pos.z}, {name="glowtest:stonetree"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- SAPLINGS
|
|
|
|
-- Green Sapling
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:sgreensapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_sgreentree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:mgreensapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_mgreentree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:lgreensapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_lgreentree(pos)
|
|
end,
|
|
})
|
|
|
|
--Blue Sapling
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:sbluesapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_sbluetree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:mbluesapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_mbluetree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:lbluesapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_lbluetree(pos)
|
|
end,
|
|
})
|
|
|
|
--Pink Sapling
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:spinksapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_spinktree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:mpinksapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_mpinktree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:lpinksapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_lpinktree(pos)
|
|
end,
|
|
})
|
|
|
|
--Yellow Sapling
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:syellowsapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_syellowtree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:myellowsapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_myellowtree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:lyellowsapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_lyellowtree(pos)
|
|
end,
|
|
})
|
|
|
|
--White Sapling
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:swhitesapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_swhitetree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:mwhitesapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_mwhitetree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:lwhitesapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_lwhitetree(pos)
|
|
end,
|
|
})
|
|
|
|
--Red Sapling
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:sredsapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_sredtree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:mredsapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_mredtree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:lredsapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_lredtree(pos)
|
|
end,
|
|
})
|
|
|
|
--Black Sapling
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:sblacksapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_sblacktree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:mblacksapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_mblacktree(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_abm({
|
|
nodenames = {"glowtest:lblacksapling"},
|
|
interval = GREINT,
|
|
chance = GRECHA,
|
|
action = function(pos, node, active_object_count, active_object_count_wider)
|
|
glowtest_lblacktree(pos)
|
|
end,
|
|
})
|
|
|
|
--Ores
|
|
|
|
minetest.register_ore({
|
|
ore_type = "scatter",
|
|
ore = "glowtest:glow_ore_cursed",
|
|
wherein = "default:desert_stone",
|
|
clust_scarcity = 12*12*12,
|
|
clust_num_ores = 5,
|
|
clust_size = 3,
|
|
height_min = -100,
|
|
height_max = 10,
|
|
flags = "absheight",
|
|
})
|
|
|
|
minetest.register_ore({
|
|
ore_type = "scatter",
|
|
ore = "glowtest:glow_ore",
|
|
wherein = "default:dirt",
|
|
clust_scarcity = 12*12*12,
|
|
clust_num_ores = 5,
|
|
clust_size = 3,
|
|
height_min = -100,
|
|
height_max = 10,
|
|
flags = "absheight",
|
|
})
|