forked from mtcontrib/minetest-mod-snow
425 lines
11 KiB
Lua
425 lines
11 KiB
Lua
-- 2D noise for coldness
|
|
|
|
local np_cold = {
|
|
offset = 0,
|
|
scale = 1,
|
|
spread = {x=150, y=150, z=150},
|
|
seed = 112,
|
|
octaves = 3,
|
|
persist = 0.5
|
|
}
|
|
|
|
-- 2D noise for icetype
|
|
|
|
local np_ice = {
|
|
offset = 0,
|
|
scale = 1,
|
|
spread = {x=80, y=80, z=80},
|
|
seed = 322345,
|
|
octaves = 3,
|
|
persist = 0.5
|
|
}
|
|
|
|
-- Debugging function
|
|
|
|
local biome_strings = {
|
|
{"snowy", "plain", "alpine", "normal", "normal"},
|
|
{"cool", "icebergs", "icesheet", "icecave", "icehole"}
|
|
}
|
|
local function biome_to_string(num,num2)
|
|
local biome = biome_strings[1][num] or "unknown "..num
|
|
return biome
|
|
end
|
|
|
|
|
|
local function do_ws_func(a, x)
|
|
local n = x/(16000)
|
|
local y = 0
|
|
for k=1,1000 do
|
|
y = y + 1000*(math.sin(math.pi * k^a * n)/(math.pi * k^a))
|
|
end
|
|
return y
|
|
end
|
|
|
|
local ws_lists = {}
|
|
local function get_ws_list(a,x)
|
|
ws_lists[a] = ws_lists[a] or {}
|
|
local v = ws_lists[a][x]
|
|
if v then
|
|
return v
|
|
end
|
|
v = {}
|
|
for x=x,x + (80 - 1) do
|
|
local y = do_ws_func(a, x)
|
|
v[x] = y
|
|
end
|
|
ws_lists[a][x] = v
|
|
return v
|
|
end
|
|
|
|
|
|
local plantlike_ids = {}
|
|
local function is_plantlike(id)
|
|
if plantlike_ids[id] ~= nil then
|
|
return plantlike_ids[id]
|
|
end
|
|
local node = minetest.registered_nodes[minetest.get_name_from_content_id(id)]
|
|
if not node then
|
|
plantlike_ids[id] = false
|
|
return false
|
|
end
|
|
local drawtype = node.drawtype
|
|
if not drawtype
|
|
or drawtype ~= "plantlike" then
|
|
plantlike_ids[id] = false
|
|
return false
|
|
end
|
|
plantlike_ids[id] = true
|
|
return true
|
|
end
|
|
|
|
local c, known_plants
|
|
local function define_contents()
|
|
c = {
|
|
dirt_with_grass = minetest.get_content_id("default:dirt_with_grass"),
|
|
dirt = minetest.get_content_id("default:dirt"),
|
|
tree = minetest.get_content_id("default:tree"),
|
|
apple = minetest.get_content_id("default:apple"),
|
|
snow = minetest.get_content_id("default:snow"),
|
|
snow_block = minetest.get_content_id("default:snowblock"),
|
|
dirt_with_snow = minetest.get_content_id("default:dirt_with_snow"),
|
|
air = minetest.get_content_id("air"),
|
|
ignore = minetest.get_content_id("ignore"),
|
|
stone = minetest.get_content_id("default:stone"),
|
|
dry_shrub = minetest.get_content_id("default:dry_shrub"),
|
|
snow_shrub = minetest.get_content_id("snow:shrub"),
|
|
leaves = minetest.get_content_id("default:leaves"),
|
|
jungleleaves = minetest.get_content_id("default:jungleleaves"),
|
|
junglegrass = minetest.get_content_id("default:junglegrass"),
|
|
ice = minetest.get_content_id("default:ice"),
|
|
water = minetest.get_content_id("default:water_source"),
|
|
papyrus = minetest.get_content_id("default:papyrus"),
|
|
sand = minetest.get_content_id("default:sand"),
|
|
}
|
|
known_plants = snow.known_plants or {}
|
|
end
|
|
|
|
minetest.register_on_generated(function(minp, maxp, seed)
|
|
local t1 = os.clock()
|
|
|
|
local x0 = minp.x
|
|
local z0 = minp.z
|
|
local x1 = maxp.x
|
|
local z1 = maxp.z
|
|
|
|
local spawn_pine = snow.voxelmanip_pine
|
|
local smooth = snow.smooth_biomes
|
|
|
|
if not c then
|
|
define_contents()
|
|
end
|
|
|
|
local vm, emin, emax = minetest.get_mapgen_object("voxelmanip")
|
|
local area = VoxelArea:new({MinEdge=emin, MaxEdge=emax})
|
|
local data = vm:get_data()
|
|
|
|
local snow_tab,num = {},1
|
|
|
|
local sidelen = x1 - x0 + 1
|
|
local chulens = {x=sidelen, y=sidelen, z=sidelen}
|
|
local nvals_cold = minetest.get_perlin_map(np_cold, chulens):get2dMap_flat({x=x0, y=z0})
|
|
local nvals_ice = minetest.get_perlin_map(np_ice, chulens):get2dMap_flat({x=x0, y=z0})
|
|
|
|
-- Choose biomes
|
|
local pr = PseudoRandom(seed+57)
|
|
-- Land biomes
|
|
local biome = pr:next(1, 5)
|
|
local snowy = biome == 1 -- spawns snow
|
|
local alpine = biome == 3 -- rocky terrain
|
|
-- Misc biome settings
|
|
local icy = pr:next(1, 2) == 2 -- if enabled spawns ice in sand instead of snow blocks
|
|
local shrubs = pr:next(1,2) == 1 -- spawns dry shrubs in snow
|
|
local pines = pr:next(1,2) == 1 -- spawns pines
|
|
-- Reseed random
|
|
pr = PseudoRandom(seed+68)
|
|
|
|
-- Loop through columns in chunk
|
|
local write_to_map = false
|
|
local ni = 1
|
|
for z = z0, z1 do
|
|
for x = x0, x1 do
|
|
local in_biome = false
|
|
local test = math.min(nvals_cold[ni], 1)
|
|
if smooth
|
|
and not snowy then
|
|
if (test > 0.73 or (test > 0.43 and pr:next(0,29) > (0.73 - test) * 100 )) then
|
|
in_biome = true
|
|
end
|
|
elseif test > 0.53 then
|
|
in_biome = true
|
|
end
|
|
|
|
if not in_biome then
|
|
if alpine and test > 0.43 then
|
|
-- remove trees near alpine
|
|
local ground_y = nil
|
|
for y = maxp.y, minp.y, -1 do
|
|
local nodid = data[area:index(x, y, z)]
|
|
if nodid ~= c.air
|
|
and nodid ~= c.ignore then
|
|
ground_y = y
|
|
break
|
|
end
|
|
end
|
|
|
|
if ground_y then
|
|
local vi = area:index(x, ground_y, z)
|
|
if data[vi] == c.leaves
|
|
or data[vi] == c.jungleleaves then
|
|
for y = ground_y, -16, -1 do
|
|
local vi = area:index(x, y, z)
|
|
local id = data[vi]
|
|
if id ~= c.air then
|
|
if id == c.leaves
|
|
or id == c.jungleleaves
|
|
or id == c.tree
|
|
or id == c.apple then
|
|
data[vi] = c.air
|
|
else
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
else
|
|
write_to_map = true
|
|
local icetype = nvals_ice[ni]
|
|
local cool = icetype > 0 -- only spawns ice on edge of water
|
|
local icebergs = icetype > -0.2 and icetype <= 0
|
|
local icehole = icetype > -0.4 and icetype <= -0.2 -- icesheet with holes
|
|
local icesheet = icetype > -0.6 and icetype <= -0.4
|
|
local icecave = icetype <= -0.6
|
|
|
|
local ground_y
|
|
for y = maxp.y, minp.y, -1 do
|
|
local nodid = data[area:index(x, y, z)]
|
|
if nodid ~= c.air and nodid ~= c.ignore then
|
|
ground_y = y
|
|
break
|
|
end
|
|
end
|
|
|
|
if ground_y then
|
|
local node = area:index(x, ground_y, z)
|
|
local c_ground = data[node]
|
|
|
|
if c_ground == c.dirt_with_grass then
|
|
if alpine
|
|
and test > 0.53 then
|
|
snow_tab[num] = {ground_y, z, x, test}
|
|
num = num+1
|
|
-- generate stone ground
|
|
for y = ground_y, math.max(-6, minp.y-6), -1 do
|
|
local vi = area:index(x, y, z)
|
|
if data[vi] == c.stone then
|
|
break
|
|
end
|
|
data[vi] = c.stone
|
|
end
|
|
elseif pines
|
|
and pr:next(1,36) == 1 then
|
|
data[node] = c.dirt_with_snow
|
|
spawn_pine({x=x, y=ground_y+1, z=z}, area, data)
|
|
elseif shrubs
|
|
and pr:next(1,928) == 1 then
|
|
data[node] = c.dirt_with_snow
|
|
data[area:index(x, ground_y+1, z)] = c.dry_shrub
|
|
else
|
|
data[node] = c.dirt_with_snow
|
|
snow_tab[num] = {ground_y, z, x, test}
|
|
num = num+1
|
|
end
|
|
elseif c_ground == c.water then
|
|
if not icesheet
|
|
and not icecave
|
|
and not icehole then
|
|
local nds = {
|
|
data[area:index(x+1, ground_y, z)],
|
|
data[area:index(x, ground_y, z+1)],
|
|
data[area:index(x+1, ground_y, z+1)],
|
|
data[area:index(x-1, ground_y, z-1)],
|
|
data[area:index(x-1, ground_y, z)],
|
|
data[area:index(x, ground_y, z-1)],
|
|
}
|
|
local ice
|
|
if pr:next(1,4) == 1
|
|
and (cool or icebergs) then
|
|
for _,i in ipairs(nds) do
|
|
if i == c.ice then
|
|
ice = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if not ice then
|
|
for _,i in ipairs(nds) do
|
|
if i ~= c.water
|
|
and i ~= c.ice
|
|
and i ~= c.air
|
|
and i ~= c.ignore then
|
|
ice = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
local y = data[area:index(x, ground_y-1, z)]
|
|
if ice
|
|
or (y ~= c.water and y ~= c.ice) -- and y ~= "air") …I don't think y can be a string here ~HybridDog
|
|
or (icebergs and pr:next(1,6) == 1) then
|
|
data[node] = c.ice
|
|
end
|
|
else
|
|
if icesheet
|
|
or icecave
|
|
or (icehole and pr:next(1,10) > 1) then
|
|
data[node] = c.ice
|
|
end
|
|
if icecave then
|
|
for y = ground_y-1, -33, -1 do
|
|
local vi = area:index(x, y, z)
|
|
if data[vi] ~= c.water then
|
|
break
|
|
end
|
|
data[vi] = c.air
|
|
end
|
|
end
|
|
if icesheet then
|
|
-- put snow onto icesheets
|
|
snow_tab[num] = {ground_y, z, x, test}
|
|
num = num+1
|
|
end
|
|
end
|
|
elseif c_ground == c.leaves
|
|
or c_ground == c.jungleleaves
|
|
or c_ground == c.apple then
|
|
if alpine then
|
|
-- make stone pillars out of trees
|
|
for y = ground_y, math.max(-6, minp.y-6), -1 do
|
|
local stone = area:index(x, y, z)
|
|
if data[stone] == c.stone then
|
|
break
|
|
end
|
|
data[stone] = c.stone
|
|
end
|
|
end
|
|
-- put snow onto it
|
|
snow_tab[num] = {ground_y, z, x, test}
|
|
num = num+1
|
|
elseif c_ground == c.sand then
|
|
if icy then
|
|
data[node] = c.ice
|
|
end
|
|
snow_tab[num] = {ground_y, z, x, test}
|
|
num = num+1
|
|
elseif c_ground == c.papyrus then
|
|
snow_tab[num] = {ground_y, z, x, test}
|
|
num = num+1
|
|
-- replace papyrus plants with snowblocks
|
|
local y = ground_y
|
|
for _ = 1,7 do
|
|
local vi = area:index(x, y, z)
|
|
if data[vi] == c.papyrus then
|
|
data[vi] = c.snow_block
|
|
y = y-1
|
|
else
|
|
break
|
|
end
|
|
end
|
|
elseif is_plantlike(c_ground) then
|
|
local vi = area:index(x, ground_y-1, z)
|
|
if data[vi] == c.dirt_with_grass then
|
|
-- replace other plants with shrubs
|
|
data[vi] = c.dirt_with_snow
|
|
data[node] = known_plants[c_ground] or c.snow_shrub
|
|
end
|
|
end
|
|
end
|
|
end
|
|
ni = ni + 1
|
|
end
|
|
end
|
|
|
|
local param2s
|
|
if num ~= 1 then
|
|
for _,i in pairs(snow_tab) do
|
|
-- set snow
|
|
data[area:index(i[3], i[1]+1, i[2])] = c.snow
|
|
end
|
|
local wsz, wsx
|
|
for _,i in pairs(snow_tab) do
|
|
local y,z,x,test = unpack(i)
|
|
test = (test-0.53)/0.47 -- /(1-0.53)
|
|
if test > 0 then
|
|
local maxh = math.floor(test*10)%10+1
|
|
if maxh ~= 1 then
|
|
if not wsz then
|
|
wsz = get_ws_list(5, z0)
|
|
wsx = get_ws_list(2, x0)
|
|
end
|
|
local h = math.floor(wsx[x]+wsz[z]*5)%10+1
|
|
if h ~= 1 then
|
|
-- search for nearby snow
|
|
y = y+1
|
|
for i = -1,1,2 do
|
|
for _,cord in pairs({{x+i,z}, {x,z+i}}) do
|
|
local nd = data[area:index(cord[1], y, cord[2])]
|
|
if nd == c.air
|
|
or is_plantlike(nd) then
|
|
h = h/2
|
|
end
|
|
end
|
|
end
|
|
h = math.floor(h+0.5)
|
|
if h > 1 then
|
|
-- make snowdrifts walkable
|
|
if h == 10 then
|
|
h = 5
|
|
end
|
|
h = math.min(maxh, h)
|
|
local vi = area:index(x, y, z)
|
|
if h == 9 then
|
|
-- replace the snow with a snowblock because its a full node
|
|
data[vi] = c.snow_block
|
|
else
|
|
-- set a specific snow height
|
|
if not param2s then
|
|
param2s = vm:get_param2_data()
|
|
end
|
|
param2s[vi] = h*7
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
vm:set_data(data)
|
|
if param2s then
|
|
vm:set_param2_data(param2s)
|
|
end
|
|
vm:set_lighting({day=0, night=0})
|
|
vm:calc_lighting()
|
|
vm:write_to_map()
|
|
|
|
if write_to_map
|
|
and snow.debug then -- print if any column of mapchunk was snow biome
|
|
local biome_string = biome_to_string(biome)
|
|
local chugent = math.ceil((os.clock() - t1) * 1000)
|
|
print("[snow] "..biome_string.." x "..minp.x.." z "..minp.z.." time "..chugent.." ms")
|
|
end
|
|
end)
|
|
|