init.lua

local path = "heightmap.dat"
local conf_path = "heightmap.dat.conf"

local worldpath = minetest.get_worldpath()
local modpath = minetest.get_modpath(minetest.get_current_modname())

file = io.open(worldpath .. "/" .. path)
local conf = Settings(worldpath .. "/" .. conf_path)

-- Configuration
local scale_x = tonumber(conf:get("scale_x")) or 1
local scale_y = tonumber(conf:get("scale_y")) or conf:get("scale") or 1
local scale_z = tonumber(conf:get("scale_z")) or 1
local offset_x = tonumber(conf:get("offset_x")) or 0
local offset_y = tonumber(conf:get("offset_y")) or 0
local offset_z = tonumber(conf:get("offset_z")) or 0

local function get_bool(name)
	local v = conf:get_bool(name)
	if v == nil then
		return true -- Enable by default, disable only if explicitly set to false
	end
	return false
end

local enable_rivers = get_bool("rivers")
local enable_landcover = get_bool("landcover")
local enable_trees = get_bool("trees")
local enable_plants = get_bool("plants")

local remove_delay = 10 -- Number of mapgen calls until a chunk is unloaded

local function parse(str, signed) -- little endian
	local bytes = {str:byte(1, -1)}
	local n = 0
	local byte_val = 1
	for _, byte in ipairs(bytes) do
		n = n + (byte * byte_val)
		byte_val = byte_val * 256
	end
	if signed and n >= byte_val / 2 then
		return n - byte_val
	end
	return n
end

if file:read(5) ~= "GEOMG" then
	print('[geo_mapgen] WARNING: file may not be in the appropriate format. Signature "GEOMG" not recognized.')
end

local version = parse(file:read(1))

-- Geometry stuff
local frag = parse(file:read(2))
local X = parse(file:read(2))
local Z = parse(file:read(2))
local chunks_x = math.ceil(X / frag) -- Number of chunks along X axis
local chunks_z = math.ceil(Z / frag) -- Number of chunks along Z axis

local xmin = math.ceil(offset_x)
local xmax = math.floor(X/scale_x+offset_x)
local zmin = math.ceil(-Z/scale_z+offset_z)
local zmax = math.floor(offset_z)

local last_chunk_length = (X-1) % frag + 1 -- Needed for incrementing index because last chunk may be truncated in length and therefore need an unusual increment

local function displaytime(time)
	return math.floor(time * 1000000 + 0.5) / 1000 .. " ms"
end

-- Metatables
local function load_chunk(layer, n)
	print("[geo_mapgen]   Loading chunk " .. n)
	local t1 = os.clock()

	local index = layer.index
	local address_min = index[n-1] -- inclusive
	local address_max = index[n] -- exclusive
	local count = address_max - address_min
	file:seek("set", layer.offset + address_min)
	local data_raw = minetest.decompress(file:read(count))
	layer[n] = data_raw -- Put raw data in table
	layer.delay[n] = remove_delay -- Set delay for this chunk
	
	local t2 = os.clock()
	print("[geo_mapgen]   Loaded chunk " .. n .. " in " .. displaytime(t2-t1))
	return data_raw
end

local mt = {__index = load_chunk} -- Metatable that will allow to load chunks on request

local delays = {} -- Will be a list of delay tables. A delay table is a table that contains the delay before unload of every loaded chunk.

local heightmap = nil
local rivermap = nil
local rivers = false
local biomemap = nil
local biomes = false
local biome_list = {}

-- Layers
local layers = {}
local layer_count = parse(file:read(1))
for l=1, layer_count do
	local datatype = parse(file:read(1)) -- Type of data: 0 = heightmap, 1 = rivermap
	local itemsize_raw = parse(file:read(1))
	local signed = false
	local itemsize = itemsize_raw
	if itemsize >= 16 then
		signed = true
		itemsize = itemsize_raw - 16
	end

	local index_length = parse(file:read(4))
	local meta = ""
	if version >= 1 then
		local meta_length = parse(file:read(2))
		meta = file:read(meta_length)
	end

	local index_raw = minetest.decompress(file:read(index_length))
	local index = {[0] = 0} -- Variable is called index instead of table to avoid name conflicts. Will contain a list of the ending position for every chunk, begin at chunk 1, so (unexisting) chunk 0 would end at pos 0. This makes simpler the calculation of chunk size that is index[i] - index[i-1] even for i=1.
	for i=1, #index_raw / 4 do
		index[i] = parse(index_raw:sub(i*4-3, i*4))
	end

	local delay = {} -- Delay table, will contain the number of mapgen calls before unloading, for every loaded chunk
	delays[l] = delay

	local layer = {
		delay = delay,
		offset = file:seek(), -- Position of first data
		itemsize = itemsize,
		signed = signed,
		index = index,
		meta = meta,
	}

	delay.data = layer -- Reference layer in delay table

	setmetatable(layer, mt)

	if datatype == 0 then -- Code for heightmap
		heightmap = layer
	elseif datatype == 1 then
		print("Rivermap enabled!")
		rivermap = layer
		rivers = enable_rivers
	elseif datatype == 2 then
		print("Biomemap enabled!")
		biomemap = layer
		biomes = enable_landcover

		local biomes_by_name = dofile(modpath .. "/landcover.lua") -- Load biome descriptions
		local biomenames = meta:split(',', true)
		for i, name in ipairs(biomenames) do
			biome_list[i] = biomes_by_name[name]
		end
	end

	local data_size = index[#index]
	file:seek("cur", data_size) -- Skip data and go to the position of the next layer
end

local function choose_deco(decos)
	local r = math.random()
	for _, deco_params in ipairs(decos) do
		local prob = deco_params.prob
		if r < prob then
			local deco = deco_params.deco
			return deco.list[math.random(#deco.list)], deco.is_schem
		else
			r = r - prob
		end
	end
end

local data = {}

minetest.register_on_mapgen_init(function(mgparams)
	minetest.set_mapgen_params({mgname="singlenode", flags="nolight"})
end)

-- Timing stuff
local mapgens = 0
local time_sum = 0
local time_sum2 = 0

-- Decode the value of a chunk for a given pixel
local function value(layer, nchunk, n)
	local itemsize = layer.itemsize
	return parse(layer[nchunk]:sub((n-1)*itemsize + 1, n*itemsize), layer.signed)
end

minetest.register_on_generated(function(minp, maxp, seed)
	print("[geo_mapgen] Generating from " .. minetest.pos_to_string(minp) .. " to " .. minetest.pos_to_string(maxp))
	local t0 = os.clock()

	local c_stone = minetest.get_content_id("default:stone")
	local c_dirt = minetest.get_content_id("default:dirt")
	local c_lawn = minetest.get_content_id("default:dirt_with_grass")
	local c_water = minetest.get_content_id("default:water_source")
	local c_rwater = minetest.get_content_id("default:river_water_source")

	local vm, emin, emax = minetest.get_mapgen_object("voxelmanip")
	vm:get_data(data)
	local a = VoxelArea:new({MinEdge = emin, MaxEdge = emax})
	local ystride = a.ystride

	local schems_to_generate = {}

	for x = math.max(xmin, minp.x), math.min(xmax, maxp.x) do
	for z = math.max(zmin, minp.z), math.min(zmax, maxp.z) do
		local ivm = a:index(x, minp.y, z)

		local xmap = math.floor((x-offset_x) * scale_x)
		local zmap = math.floor((z-offset_z) * scale_z)

		local xchunk = math.floor(xmap / frag)
		local zchunk = math.floor(-zmap / frag)
		local nchunk = xchunk + zchunk * chunks_x + 1
		
		local increment = frag
		if xchunk + 1 == chunks_x then -- Last chunk of the line: may be truncated, that would change the line increment.
			increment = last_chunk_length
		end
		local xpx = xmap % frag
		local zpx = -zmap % frag
		local npx = xpx + zpx * increment + 1 -- Increment is used here

		local h = math.floor(value(heightmap, nchunk, npx) / scale_y + offset_y)

		if minp.y <= math.max(h,offset_y) then
			local river_here = false
			if rivers then
				river_here = value(rivermap, nchunk, npx) > 0
			end
			local stone, filler, top = c_stone, c_dirt, c_lawn
			local nfiller, ntop = 3, 1
			local node_deco
			if biomes and h >= offset_y then
				local nbiome = value(biomemap, nchunk, npx)
				local biome = biome_list[nbiome]
				if biome then
					stone = biome.stone
					filler = biome.filler
					top = biome.top
					nfiller = biome.filler_depth
					ntop = biome.top_depth
					if enable_plants and maxp.y >= h and not river_here then -- Generate decoration
						local deco, is_schem = choose_deco(biome.decos)
						if deco then
							if is_schem then
								if enable_trees then
									table.insert(schems_to_generate, {pos={x=x-2,y=h+1,z=z-2}, schem=deco}) -- Schem size is not known. Assuming that most of schematics have a size of 5, hardcode offset to 2. TODO: Change that when schematic flags will be available on minetest.place_schematic_on_vmanip
								end
							else
								node_deco = deco
							end
						end
					end
				end
			end

			if h < offset_y then
				top = filler
			end

			local stone_min = minp.y
			local stone_max = math.min(h-nfiller, maxp.y)
			local filler_min = math.max(stone_max+1, minp.y)
			local filler_max = math.min(h-ntop, maxp.y)
			local top_min = math.max(filler_max+1, minp.y)
			local top_max = math.min(h, maxp.y)

			if river_here then
				top_max = math.min(h-1, maxp.y)
			end

			if stone_min <= stone_max then
				for y = stone_min, stone_max do
					data[ivm] = stone
					ivm = ivm + ystride
				end
			end

			if filler_min <= filler_max then
				for y = filler_min, filler_max do
					data[ivm] = filler
					ivm = ivm + ystride
				end
			end

			if top_min <= top_max then
				for y = top_min, top_max do
					data[ivm] = top
					ivm = ivm + ystride
				end
			end

			if river_here then
				data[ivm] = c_rwater
				ivm = ivm + ystride
			elseif node_deco and h >= offset_y then
				data[ivm] = node_deco
			end

			if h < offset_y then
				for y = math.max(h+1, minp.y), math.min(offset_y, maxp.y) do
					data[ivm] = c_water
					ivm = ivm + ystride
				end
			end
		end
	end
	end

	vm:set_data(data)
	for _, params in ipairs(schems_to_generate) do
		minetest.place_schematic_on_vmanip(vm, params.pos, params.schem, "random", nil, false) -- Place schematics
	end
	vm:set_lighting({day = 0, night = 0})
	vm:calc_lighting()
	vm:update_liquids()
	vm:write_to_map()

	-- Decrease delay, remove chunks from cache when time is over
	for _, layer_delays in ipairs(delays) do
		for n, delay in pairs(layer_delays) do
			if n ~= "data" then -- avoid the "data" field!
				if delay <= 1 then
					layer_delays[n] = nil
					layer_delays.data[n] = nil -- layer_delays.data is the layer itself
					print("[geo_mapgen]   Uncaching chunk " .. n)
				else
					layer_delays[n] = delay - 1
				end
			end
		end
	end

	local t3 = os.clock()
	local time = t3 - t0
	print("[geo_mapgen] Mapgen finished in " .. displaytime(time))

	mapgens = mapgens + 1
	time_sum = time_sum + time
	time_sum2 = time_sum2 + time ^ 2
end)

minetest.register_on_shutdown(function()
	print("[geo_mapgen] Mapgen calls: " .. mapgens)
	local average = time_sum / mapgens
	print("[geo_mapgen] Average time: " .. displaytime(average))
	local stdev = math.sqrt(time_sum2 / mapgens - average ^ 2)
	print("[geo_mapgen] Standard dev: " .. displaytime(stdev))
end)