init.lua

---============================================================================
--MG TECTONIC
--By Dokimi

--A naturalistic mapgen.
--This is the main mapgen code.

--=============================================================================
--PRELIMINARIES
mgtec = {}
local mod_storage = minetest.get_mod_storage()

---------------------
--SINGLENODE
minetest.set_mapgen_params({mgname = "singlenode", flags = "nolight"})

--Despite being the up to date method this doesn't work
--minetest.set_mapgen_setting("mgname", "singlenode", true)
--minetest.set_mapgen_setting("flags", "nolight", true)



-----------------
--PLANTS API
dofile(minetest.get_modpath("mg_tectonic").."/trees.lua")
dofile(minetest.get_modpath("mg_tectonic").."/plants_api.lua")
dofile(minetest.get_modpath("mg_tectonic").."/plants.lua")
--may cause bugs????
if minetest.get_modpath("mgt_flora") ~= nil then
	dofile(minetest.get_modpath("mgt_flora").."/plants_reg.lua")
end


if mgtec.registered_on_first_mapgen then -- Run callbacks
	for _, f in ipairs(mgtec.registered_on_first_mapgen) do
		f()
	end
	mgtec.registered_on_first_mapgen = nil
	mgtec.register_on_first_mapgen = nil
end

--=============================================================================
-- PARAMETERS
----------------------
--MISC
-- the edge of the map
local YMAX = 31000
local YMIN = -31000

 --sealevel
local SEA = 0

--height of lava
local MAXMAG = -15000

-------------------
--BASE LAYER:
-- Wave Roll Size: i.e Period
--Controls distance between ranges, and thickness.
--This is the period at the map centre. Grows to double at map edges
--will effect gradient and number of major mt ranges
local XRS = 537--617

--Where does the continental shelf end?
local SHELFX = 25000
local SHELFZ = 28000
--How deep are the oceans?
local SEABED = -15000
--Strength of noise on continental shelf boundaries lines
local CONOI = 2500

--Cave size.
--Base cave threshold for fissures
local BCAVTF = 0.0079

--Base cave threshold for caves
local BCAVT = 0.996

--Ore threshold
local ORET = 0.975





--==================================================================
--FUNCTIONS

--Checks if this is a place for ore deposits.

local function ore(nocave, ab_stra, ab_cave, ab_cave2, y, ORET, ybig, n_strata, data, vi, OREID)
	--c_coal, c_iron, c_copp, c_tin, c_gold, c_diam, c_mese

	--strata thickness
	local thick = 100 + (50 * ab_stra)

	--strata splits for ore types..
	local t1 = 0.25
	local t2 = 0.5
	local t3 = 0.83

	local ystrata = math.sin(y/thick)

	 --a fair sine wave split, with low value ores dominant
	 --[[for reference... if the above gets confusing
	local ysmin_coal = 0 * TSTRA
	local ysmax_coal = 0.25 * TSTRA
	local ysmin_cop = 0.25 * TSTRA
	local ysmax_cop = 0.5 * TSTRA
	local ysmin_gol = 0.5 * TSTRA
	local ysmax_gol = 0.83 * TSTRA
	local ys_mese1 = 0.83 * TSTRA --mese is on the ends of the range
	local ysmin_iron = -0.25 * TSTRA
	local ysmax_iron = 0 * TSTRA
	local ysmax_tin = -0.25 * TSTRA
	local ysmin_tin = -0.5 * TSTRA
	local ysmax_dia = -0.5 * TSTRA
	local ysmin_dia = -0.83 * TSTRA
	local ys_mese2 = -0.83 * TSTRA
	--]]


	--threshold adjusted with depth to get bigger down deep.
	local ore_t = ORET + ybig

	--harder if actually in the cave.
	if not nocave then
		ore_t = ore_t + 0.05
	end

	--height limits
	local blend = n_strata * 50
	local orehmin_c = -10000 + (n_strata * 500) --min height for coal (a shallow ore)
	local orehmax_g = -30 + blend   --dig a little for gold
	local orehmax_d = -600 + blend   --diamonds are deep
	local orehmax_m = -400 + blend   --mese is deep

	--above their threshold
	--add some of the cave noise to increase chance of finding ores near caves
	--working with caves: should be less inside the actual cave (less floaters), but..
	--..reduced threshold should boost approaching cave
	if ab_stra >= ore_t - (ab_cave2 * 0.02)  then

		--split them by height and strata
		--coal.
		if y > orehmin_c
		and ystrata >= 0     --strata splits
		and ystrata < t1
		then
			data[vi] = OREID.c_coal
			return true
		--iron
		elseif ystrata > -t1    --strata splits
		and ystrata < 0 then
			data[vi] = OREID.c_iron
			return true
		--copper
		elseif ystrata > t1    --strata splits
		and ystrata < t2 then
			data[vi] = OREID.c_copp
			return true
		--tin
		elseif ystrata > -t2    --strata splits
		and ystrata < -t1 then
			data[vi] = OREID.c_tin
			return true
		--Gold
		elseif  y < orehmax_g
		and ystrata > t2    --strata splits
		and ystrata < t3 then
			data[vi] = OREID.c_gold
			return true
		--Diamonds
		elseif y < orehmax_d
		and ystrata > -t3    --strata splits
		and ystrata < -t2 then
			data[vi] = OREID.c_diam
			return true
		--Mese
		elseif y < orehmax_m
		and (ystrata > t3    --strata splits, end of range
		or ystrata < -t3) then
			data[vi] = OREID.c_mese
			return true
		end
			--end of ores
	else
		--have to let it know so it can set void etc
		return false
	end
	--end of all ores
end
--End of Ore function



------------------------------
--Climate Calculations.
--this function can be called by other mods instead of default biome climate checks

mgtec.climate = function(x, z, y, n_terr, n_terr2)


	--east = + x, west = - x, south = -z, n = + z
	--Climate is decided by:
	-- -Ranges: rains come from the west (-x), rise over the ranges dumping cooling rain, descending hot and dry (east +x)
	-- - Altitude: it's cold up there.
	-- - Latitude: hot north, cold south

	--blending
	local blend = math.random(-4, 4)

	--to help climate be accessed by other mods (mainly weather)
	--we will ignore noise (thorn0906's solution crashes when actually used,
	-- accessing noise repeatedly likely very heavy for little gain
	-- reducing noiseyness better? Randomness can make things throw a fit)
	if n_terr == nil or n_terr2 == nil then
		blend = 0
		n_terr = 0
		n_terr2 = 0
	end


	--We are Southern Hemisphererers here!
	--decreasing temp from max z to min z (latitude) (from 100 to 0 i.e north desert to south ice)
	-- linear increase, intercept at 50
	local temp_z = (0.00163*z) + 50 - blend


	-- no Fohn? Westies are controlled by z only
	local temp_x = 0

  local lon_blend = (blend*3) + n_terr * 200 --offset east-west border with some noise

	-- Easterners?
	if x > lon_blend then
		--Fohn Winds! They are hot! The East Coast gets a temp boost
		-- adds + 20 at centre of map, declines to zero
		temp_x = (-0.00065*x) + 20 - blend
	end



	--Mountain tops ought to be cold!
	--decreasing temp with hieght...and combine previous two as baseline
	local temp = temp_z + temp_x - blend
	--only apply height adjustment above sea level, otherwise cooking oceans
	--large parts of "lowlands" are very high too, so start cooling high.
	--i.e. -0.05 = -50 at 1000m
	if y >= 200 + (n_terr *75) then
		temp = (-0.05*y) + temp_z + temp_x - blend
	end

	---------------
	--what's the humidity? Rainshadow!
	--decreasing humid from far x to x= 0,(rain shadow)
	--tip a little past 50 for greater variety
	--i.e. 0-60, so have wet islands on the dry side, dry islands on wet side

	--if in doubt ...
	local hum = 50

	----poitive, east coast. Dry inland
	--linear increase,
	if x > lon_blend then
		hum = (0.00194*x) + blend
	--increasing humid from far x to x= 0,(rain shadow)
	else  --negative , west coast. Wet inland
		--linear increase,
		--starts a little lower than max (i.e. + <100)
		--so that altitude boosts it to max
		hum = (0.00145*x) + 85 + blend
	end


	--Transition humidity
	--this is to avoid a sharp line East West
	-- not perfect but better than nothing?
	if x > lon_blend and x < lon_blend + 400 then
		--east must be wetter
		if x < lon_blend + 100 then
			hum = hum + 35
		elseif x < lon_blend + 200 then
			hum = hum + 20
		else
			hum = hum + 15
		end
	elseif x < lon_blend and x > lon_blend - 300 then
		--west must be drier
		if x > lon_blend - 100 then
			hum = hum - 20
		elseif x > lon_blend - 200 then
			hum = hum - 10
		else
			hum = hum - 5
		end
	end


	--disturbance regime
	--i.e. ecological succession
	local distu =  math.abs(n_terr * 100 + blend)


	--altitude effects..
	--coast is wet, but disturbed
	-- hill tops catch rain but are more disturbed
	if y > 490 or (y < 10 and y > -3) then
		--alpine (force snowy)
		if y > 1200 + math.random(-30, 5) then
			hum = hum + 48
			temp = temp - 32
			distu = distu + 12
			--subalpine
		elseif y > 1100 + blend then
			hum = hum + 24
			temp = temp - 16
			distu = distu + 6
		elseif y > 1000 + blend then
			hum = hum + 12
			temp = temp - 8
			distu = distu + 3
			--montane
		elseif y > 900 + blend then
			temp = temp - 4
			hum = hum + 6
		elseif y > 700 + blend then
			temp = temp - 2
			hum = hum + 3
		elseif y > 500 + blend then
			hum = hum + 2
			--coast
		elseif (y <= 3 and y >= -1) then
			-- generally wetter, but sometimes drier
			--..coasts are more variable
			hum = hum + 3 + blend
			distu = distu + 5
		end
	end


	--disturbance Feedsback on micro-climate
	--calm areas hold water.
	--exposed areas are hotter
	--sheltered a little colder
	if distu <15 or distu >80 then
		if distu < 10 then
			if distu <5 then
				hum = hum + 8
				temp = temp - 4
			elseif distu <15 then
				hum = hum + 4
				temp = temp - 2
			end
		elseif distu > 80 then
			if distu > 95 then
				hum = hum - 12
				temp = temp + 12
			elseif distu > 90 then
				hum = hum - 6
				temp = temp + 6
			elseif distu > 80 then
				hum = hum - 3
				temp = temp + 3
			end
		end
	end


return temp, hum, distu
--done climate calculations
end

-------------------------------------
--Create Swamp
local function swamp(data, vi, chance, mud, water)


	--let's place a messy swampy mire
	local roll = math.random(1, chance)
	if roll == 1 then
		data[vi] = water
	else
		data[vi] = mud
	end
--end of swamp
end




--End of functions




--=============================================================================
--IDs
-- Get the content IDs for the nodes used.

--rocks
local c_stone = minetest.get_content_id("default:stone")
local c_stone2 = minetest.get_content_id("default:desert_stone")
local c_sandstone = minetest.get_content_id("default:desert_sandstone")
local c_sandstone2 = minetest.get_content_id("default:sandstone")
local c_sandstone3 = minetest.get_content_id("default:silver_sandstone")
local c_obsid = minetest.get_content_id("default:obsidian")
local c_coral = minetest.get_content_id("default:coral_skeleton")
local c_coralb = minetest.get_content_id("default:coral_brown")
local c_coralo = minetest.get_content_id("default:coral_orange")



--sediments
local SEDID = {
 			c_gravel = minetest.get_content_id("default:gravel"),
 			c_clay = minetest.get_content_id("default:clay"),
 			c_sand = minetest.get_content_id("default:sand"),
 			c_sand2 = minetest.get_content_id("default:silver_sand"),
 			c_dirt = minetest.get_content_id("default:dirt"),
			c_perma = minetest.get_content_id("default:permafrost"),
}

--surfaces
local c_dirtgr = minetest.get_content_id("default:dirt_with_grass")
local c_dirtdgr = minetest.get_content_id("default:dirt_with_dry_grass")
local c_dirtsno = minetest.get_content_id("default:dirt_with_snow")
local c_dirtlit = minetest.get_content_id("default:dirt_with_rainforest_litter")
local c_dirtconlit = minetest.get_content_id("default:dirt_with_coniferous_litter")
local c_snowbl = minetest.get_content_id("default:snowblock")
local c_snow = minetest.get_content_id("default:snow")
local c_ice = minetest.get_content_id("default:ice")
local c_dsand = minetest.get_content_id("default:desert_sand")
local c_permamoss = minetest.get_content_id("default:permafrost_with_moss")
local c_permastone = minetest.get_content_id("default:permafrost_with_stones")


--Miscellaneous

local MISCID = {
		c_water = minetest.get_content_id("default:water_source"),
		c_river = minetest.get_content_id("default:river_water_source"),
		c_air = minetest.get_content_id("air"),
		c_ignore = minetest.get_content_id("ignore"),
		c_lava = minetest.get_content_id("default:lava_source"),
		c_kelpsand = minetest.get_content_id("default:sand_with_kelp"),
		c_coral_cyan = minetest.get_content_id("default:coral_cyan"),
		c_coral_green = minetest.get_content_id("default:coral_green"),
		c_coral_pink = minetest.get_content_id("default:coral_pink"),

}

--ores
local OREID = {
		c_diam = minetest.get_content_id("default:stone_with_diamond"),
		c_mese = minetest.get_content_id("default:stone_with_mese"),
		c_gold = minetest.get_content_id("default:stone_with_gold"),
		c_copp = minetest.get_content_id("default:stone_with_copper"),
		c_tin = minetest.get_content_id("default:stone_with_tin"),
		c_iron = minetest.get_content_id("default:stone_with_iron"),
		c_coal = minetest.get_content_id("default:stone_with_coal")
}




--=============================================================================
--NOISES

-- 2D Mountain Terrain.
--controls: large rounded mountains.
local np_terrain = {
   offset = 0,
   scale = 1,
   spread = {x = 1944, y = 3078, z = 1944},
   seed = 110013,
   octaves = 5,
   persist = 0.3,
   lacunarity = 3,
	 --flags = 'noeased',
}

-- 2D Soft rock Terrain.
--controls: sharp peaks
local np_terrain2 = {
   offset = 0,
   scale = 1,
   spread = {x = 405, y = 243, z = 405},
   seed = 5938033,
   octaves = 3,
   persist = 0.6,
   lacunarity = 3,
	 flags = 'noeased',
}


-- 3D Caves 1
--used by: fissures in basement rock,
local np_cave = {
   offset = 0,
   scale = 1,
   spread = {x = 108, y = 243, z = 324},
   seed = -9103323,
   octaves = 3,
   persist = 0.2,
   lacunarity = 3,
	 --flags = 'noeased',
}

-- 3D Caves 2
--used by: breaks in fissures, caves in basement rock
local np_cave2 = {
  offset = 0,
	scale = 1,
	spread = {x = 81, y = 27, z = 81},
	seed = 205301,
	octaves = 3,
	persist = 0.5,
  lacunarity = 3,
	flags = 'noeased',
}


--3D Strata
-- used by: ore thresholds.
local np_strata = {
   offset = 0,
   scale = 1,
   spread = {x = 81, y = 81, z = 81},
   seed = 51055033,
   octaves = 3,
   persist = 0.7, --high or get few ore
   lacunarity = 3,
}




---============================================================================
--NOISE MEMORY

-- Initialize noise object to nil. It will be created once only during the
-- generation of the first mapchunk, to minimise memory use.
local nobj_terrain = nil
local nobj_terrain2 = nil
local nobj_cave = nil
local nobj_cave2 = nil
local nobj_strata = nil
-- For getting individual n_terr values
--nobj_terr_i = nil
--nobj_terr2_i = nil

-- Localise noise buffer table outside the loop, to be re-used for all
-- mapchunks, therefore minimising memory use.
local nvals_terrain = {}
local nvals_terrain2 = {}
local nvals_cave = {}
local nvals_cave2 = {}
local nvals_strata = {}

-- Localise data buffer table outside the loop, to be re-used for all
-- mapchunks, therefore minimising memory use.
local data = {}
-- param2 data
local data2 = {}

--=============================================================================
-- GENERATION

local num_lakes = nil
local lakes = nil
local spawnpoint = {x = 0, z = 0}

minetest.register_on_mapgen_init(function(mapgen_params)


	math.randomseed(mapgen_params.seed)
  spawnpoint = {x = math.random(-23000, 23000), z = math.random(-27000, 27000)}


	-- some things need to be random, but stay constant throughout the loop

	-- number of lakes
	if lakes == nil then
		num_lakes = math.random(15,18)
		lakes = {}
		for i = 0, num_lakes do
			--keep back from "shelf" as the coastline is actually much further back
			--need to keep them out of main ranges...too much erosion.
			--choose east or west.
			if math.random(1,3) <=2 then
				--west lake
				lakes[i] = {x = math.random(-13000,-5500), z = math.random(-25000,25000), r = math.random(1,5)}
			else
				--East lake.
				lakes[i] = {x = math.random(13000,5500), z = math.random(-25000,25000), r = math.random(1,4)}
			end
			--save location for bug checking
			mod_storage:set_int("Lake"..i.."x", lakes[i].x)
			mod_storage:set_int("Lake"..i.."z", lakes[i].z)
			mod_storage:set_int("Lake"..i.."river", lakes[i].r)
		end
	end
end)

table.insert(minetest.registered_on_generateds, 1, (function(minp, maxp, seed)
  math.randomseed(seed)
	--------------------------------
	--don't do out of bounds!
	--world is a square, ymin will do for z and x too.
  if minp.x < YMIN
	or maxp.x > YMAX
	or minp.y < YMIN
	or maxp.y > YMAX
	or minp.z < YMIN
	or maxp.z > YMAX
	then
		return
	end

	-----------------------------
	-- Start time of mapchunk generation.
	local t0 = os.clock()

	--------------------------------
	-- NOISE
	-- Side length of mapchunk.
	local sidelen = maxp.x - minp.x + 1

	-- Required dimensions noise perlin map.
	--3d
	local chulen = {x = sidelen, y = sidelen, z = sidelen}
	--2d
	local chulenxz = {x = sidelen, y = sidelen, z = 1}

	local minposxyz = {x = minp.x, y = minp.y - 1, z = minp.z}
	local minposxz = {x = minp.x, y = minp.z}

	-- strides for voxelmanip
	local ystridevm = sidelen + 32
	local zstridevm = ystridevm ^ 2

	-- Create the perlin map noise object once only, during the generation of
	-- the first mapchunk when 'nobj_terrain' is 'nil'.
	nobj_terrain = nobj_terrain or minetest.get_perlin_map(np_terrain, chulenxz)
	nobj_terrain2 = nobj_terrain2 or minetest.get_perlin_map(np_terrain2, chulenxz)
	nobj_cave = nobj_cave or minetest.get_perlin_map(np_cave, chulen)
	nobj_cave2 = nobj_cave2 or minetest.get_perlin_map(np_cave2, chulen)
	nobj_strata = nobj_strata or minetest.get_perlin_map(np_strata, chulen)
	--nobj_terr_i = nobj_terr_i or minetest.get_perlin(np_terrain.seed, np_terrain.octaves, np_terrain.persist, np_terrain.scale)
	--nobj_terr2_i = nobj_terr_i or minetest.get_perlin(np_terrain2.seed, np_terrain2.octaves, np_terrain2.persist, np_terrain2.scale)

	-- Create a flat array of noise values from the perlin map, with the
	-- minimum point being 'minp'.
	-- Set the buffer parameter to use and reuse 'nvals_X' for this.
	nobj_terrain:get2dMap_flat(minposxz, nvals_terrain)
	nobj_terrain2:get2dMap_flat(minposxz, nvals_terrain2)
	nobj_cave:get3dMap_flat(minposxyz, nvals_cave)
	nobj_cave2:get3dMap_flat(minposxyz, nvals_cave2)
	nobj_strata:get3dMap_flat(minposxyz, nvals_strata)


	-----------------------------------------------------------
	-- VOXELMANIP
	-- Load the voxelmanip with the result of engine mapgen. Since 'singlenode'
	-- mapgen is used this will be a mapchunk of air nodes.
	local vm, emin, emax = minetest.get_mapgen_object("voxelmanip")

	-- 'area' is used later to get the voxelmanip indexes for positions.
	local area = VoxelArea:new{MinEdge = emin, MaxEdge = emax}

	-- Get the content ID data from the voxelmanip in the form of a flat array.
	-- Set the buffer parameter to use and reuse 'data' for this.
	vm:get_data(data)
	vm:get_param2_data(data2)

	---------------------------------------------
	-- GENERATION LOOP

	----------------------------
	--Begin the Loop

	-- Noise index for the flat array of noise values.
	-- 3D perlinmap indexes
	local nixyz = 1
	-- 2D perlinmap indexes
	local nixz = 1

	-- Process the content IDs in 'data'.
	for z = minp.z, maxp.z do
		for y = minp.y, maxp.y do
			-- Voxelmanip index for the flat array of content IDs.
		 	-- Initialise to first node in this x row.
			local vi = area:index(minp.x, y, z)
			for x = minp.x, maxp.x do

				----------------------------------------------------
			 	--Welcome to the Loop


				-----------
				--Noises
				local n_terr  = nvals_terrain[nixz]
				local n_terr2  = nvals_terrain2[nixz]
				local ab_t =  math.abs(n_terr)
				local ab_t2 =  math.abs(n_terr2)


				local n_cave = nvals_cave[nixyz]
				local n_cave2 = nvals_cave2[nixyz]
				local ab_cave = math.abs(n_cave)
				local ab_cave2 = math.abs(n_cave2)

				local n_strata = nvals_strata[nixyz]
				local ab_stra = math.abs(n_strata)

				--Get the node underneath
				local nodu  = data[(vi - ystridevm)]


				-----------
				-- Math

				--absolute for x (for symmetry on both sides of map)
				local xab = math.abs(x)
				--x axis terrain gradient. 0 at centre. 1 at edges.
				--Used by equations to adjust along x axis
				local xtgrad = (xab/YMAX)

				--amplitude... going from 1 to zero at map edge
				local whs = 1-xtgrad


				--Move up/down along x axis. Goes from +1 to -1
        --mup raises and lowers along x axis. the two terms cancel out in middle of x range (15k).
        --aimed for equations that need to lift map centre, sink edges
        local mup = whs + (-1 * xtgrad)


				------------------
				--Base Layer Waves
				--creates the underlying, undulating and mountainous terrain


				--Wave period. "Roll". i.e. how wide/steep and they are.
				--Gradient widens the ranges towards the edges.
				local x_roll = XRS + (XRS * xtgrad)   --x axis

				--The Wave!
				local xwav = (whs*math.cos(x/x_roll))    -- north south wave (main ranges)
				local xwav2 = (whs*math.cos(x/(x_roll/6.89))) --smaller more detailed wave



				--Base Wave Density.
				--This is checked against the threshold to decide where the base layer can go.
				--the wave controls the landscape folding i.e. the bunching up caused by the plates hitting eachother.
				--variation along this fold is caused by erosion, so is much more random...

				--cubing/squaring flattens out the middle range, squaring eliminates negatives
				--for the wave that gives it a flat shelf at sea level.
				--for the noise it mellows part of it out, so it adds mainly extreme peaks and dips
				--mup lowers the landscape at the edges (ocean), otherwise the flattening of height would lead to endless plains
				--wave + raise + large hills 2 + sharp hills (moderated by large or gives sky needles) + cliffs 2

				--waves
				local dwav = ((xwav2 ^ 3)*1.67) + ((xwav ^ 3)*6.89) + (mup*10.81)--+ (mup*12.16)
				--noise
				local dnoi = ((n_terr ^3) + ((n_terr)*0.5) + ((n_terr2*n_terr)*0.8)) * 2.8 * (whs + 0.02)
				--cliffs..
				local dclif1 = ((ab_stra)*0.16)
				local dclif2 = ((ab_cave*ab_cave2)*0.05)

				local den_base = dwav + dnoi - dclif1 - dclif2


				---Base Threshold (use for all of them now)
				--effects heights of landscape
				local t_base = 0.00969*y --0.01036*y



				-------------------------------------
				--Soft Rock
				--layered on top of the base layer.
				--adding to previous: x >1 = steeper. x < 1 flatter
				--soft sandstone... easily erobable rocks sedimentary rocks
				--creates regions of soft rock on top of the base layer in lowlands
				--base + boost + noise - cliff



				--density
				local den_soft = (den_base*0.4) + 1.3 + ((1-n_terr) * (2.22 - (xtgrad*2))) - dclif2
				--threshold (redundant)
				--local t_soft = 0.006*y -0.15

				------------------------------------
				--Alluvium
				--eroded rock etc, deposited on lowlands

				--density
				local den_allu = (den_soft*0.95) + 0.1 - dclif2
				--threshold (redundant)
				--local t_allu = 0.0075*y -0.17


				------------------------------------
				--Sediment
				--subsurface soils and sands
				--density
				local den_sedi = den_allu + 0.03 -- dclif2
				--threshold (redundant)
				--local t_sedi = 0.0085*y -0.18

				-------------------------------------
				--Checks
				--This is so we know if we placed something.

				local void = true  -- we have yet to set anything
				local nocave = true		--basement rock caves
				local basin = false		--ocean basin
				local river_basin = false		--river basin



				--------------------------------------------------
				--THE DECISION TREE
				-------------------------------------------------

				-------------------------------
				--Seperate Earth and Sky
				if den_base > t_base
				or den_soft > t_base
				or den_allu > t_base
				or den_sedi > t_base then

					--Seperate Earth from oceans, rivers, caves.
					----------------------------
					-- Ocean Basins/Erosion
					--carves out a continental shelf.
					--lowers mountains so can have sea at North and South
					local zab = math.abs(z)

					-- coastline
					local shelfnoi = (((n_terr ^3) + (n_terr2 *0.08)) * CONOI) - dclif2
					local shelfsl = (3 - (n_terr^3))*y --sets slope for x
					--local bed = SEABED + ((n_terr^3)*SEABED)
					--Are we in the right place for oceans?
					if (xab > ((SHELFX + (shelfnoi*2)) - shelfsl)
					or zab > ((SHELFZ + shelfnoi) - shelfsl))
					and y >= SEABED  then --max depth,
						basin = true
					end

					-----------------------------
					--Lakes and rivers.
					--These are put in "manually" as doing it based on noise does not work well for rivers
					--The point of these is:
					-- to bring water to the dry interior, provide access, features of interest, greater altitude variation.
					--they have a large erosion effect on the surrounding area. So need very steep sides
					------------------------------

					--[[
					--Central Caldera
					--To give a water feature in the middle of the map.
					--define a square which will be the lake, then soften it with noise
					local calr = (350 + (150 * n_terr) + (50 * n_terr2)) * (1 + (y/50))
					local cald = -90 + (47 * n_terr) + (47 * n_terr2)
					if xab < calr
					and zab < calr
					and y > cald then
						basin = true
					end

					-----------------------------
					--caldera island
					local calir = (55 + (25 * n_terr) + (25 * n_terr2)) * (1 - (y/(25 + n_terr2)))
					local calid = -1000 - (250 * n_terr) - (250 * n_terr2)
					if xab < calir
					and zab < calir
					and y > calid
				 	then
						if xab < calir/3
						and zab < calir/3
						and y < -150 + (50 * n_terr2)	--match to calir y cut off
						then
							--we have a lava chamber.
							data[vi] = MISCID.c_lava
							void = false
						else
							--obsidian and ore
							--small chance of minerals from volcanism..
							local roll = math.random(1,200)
							if roll == 1 then
								data[vi] = OREID.c_gold
								void = false
							elseif roll == 2 then
								data[vi] = OREID.c_copp
								void = false
							elseif roll == 3 then
								data[vi] = OREID.c_tin
								void = false
							elseif roll == 4 then
								data[vi] = OREID.c_mese
								void = false
							else
								data[vi] = c_obsid
								void = false
							end
						end
					end
--]]

					----------------------------------
					--Random lakes
					if not basin and not river_basin then
						for n = 0, num_lakes do
							local laked = -25 + (10 * n_terr2)
		    			local laker = (160 + (100 * n_terr) + (25 * n_terr2)) * (1 + (y/(160 + (20 * n_terr))))
		    			if x < lakes[n].x + (laker*1.6) and x > lakes[n].x - (laker*1.6)
							and z < lakes[n].z + laker and z > lakes[n].z - laker
							and y > laked then
								river_basin = true
							end

							--Rivers draining them
							if lakes[n].r <= 4 then
								--local interr = 1-n_terr
								local interr2 = 1-n_terr2

								--rivers have real world mathmatical geometry
								--width (actually half the width)
								local wp = (8 + (0.0003*xab))
								local w = (wp * (1 + (y/(8 + (n_terr*2))))) - ((n_terr2^3)*3)

								--period of channel
								local per_ch = ((3.5 * n_terr) + 22) * wp
								--local per_ch = 176
								--amplitude
								local am_ch = (interr2 + 4.6) * wp
								--local am_ch = 37

								--wave for channel
								local c1 = ((am_ch)*math.sin(x/per_ch))
								local c2 = (12 + (interr2*3))*math.sin(x/(56 + (n_terr*8)))
								local channel = c1 + c2

								--line it up north-south
								if z <= lakes[n].z + channel + w
								and z >= lakes[n].z + channel - w then
									--make sure the river is on the same side East-west of the map as the lake!
									--east lakes, only place the river further east
									if lakes[n].x > 0 and x + w > lakes[n].x then
										river_basin = true
										--west lakes, only place river further west
									elseif lakes[n].x < 0 and x - w < lakes[n].x then
										river_basin = true
									end
								end
							end
						end
					end
--[[
                    ----------------------------------
                    --A river running out of the caldera in some direction
                    local cx = (n_terr2*30)*math.cos(xab/42)
                    local cz = (n_terr*30)*math.cos(xab/21)
                    local w = (22 + (n_terr2*9) + (10*xtgrad)) * (1 + (y/(12 - (3*xtgrad))))
                    if x <= cx + w and x >= cx - w and z <= cz + w and z >= cz - w then
                        basin = true
                    end

					----------------------------------
					--a river running bisecting the land East/west
					local channel = (50 +(n_terr2*30))*math.cos(xab/42)
					local w = (22 + (n_terr2*9) + (10*xtgrad)) * (1 + (y/(12 - (3*xtgrad))))
					if z <= channel + w and z >= channel - w then
						basin = true
					end

					-----------------------------------
					--Mirror lake
					--gives four lakes.
					local laker = (140 + (75 * n_terr) + (75 * n_terr2)) * (1 + (y/(55 + (5 * n_terr2))))
					local laked = -25 + (20 * n_terr) + (8 * n_terr2)
					if xab < 5000 + laker and xab > 5000 - laker
					and zab < 15000 + laker and zab > 15000 - laker
					and y > laked then
						basin = true
					end

					---------------------------------
					--Mirror Rivers
					--give four rivers draining the four lakes
					local channel = (40 +(n_terr2*30))*math.cos(xab/36)
					local w = (16 + (n_terr2*7) + (10*xtgrad)) * (1 + (y/(14 - (3*xtgrad))))
					if zab <= 15000 + channel + w
					and zab >= 15000 + channel - w
					and xab > 5000 then
						basin = true
					end
--]]
					-----------------------------------
					--the following we don't want in basins
					--caves... bc they would displace water.
					--rock and ore, for obvious reasons
					if void and not basin and not river_basin then

						----------------------------------
						--Things that block base rock.
						--i.e. caves etc

						--for adding/subtracting from thresholds
						--this is to change cave size with depth
						-- goes from 1 at map top to 0 at y=0, to -1 at map bottom (modified by strength)
						local ybig = ((y/YMAX)*0.24)

						--------------
						--Fissures?
						--to get the snaking plane we need to start by emptying the world..
						nocave = false
						--now our threshold for filling back in the non-cave world
						--if the noise is above this. we have ground...
						--lower the threshold.. smaller cave
						local cav_t1 = BCAVTF - ybig

						--check... can we fill in the non-cave?
						--extra noises break up sheet
						if (ab_cave) >= cav_t1
						or (n_cave2) >= cav_t1
						then
							nocave = true
						end

						-----------------
						--Round caves?
						-- reverse deal from fissures.
						--If the noise is above the threshold we empty out a cave
						-- lower threshold = bigger cave..
						local cav_t2 = BCAVT + ybig

						if n_cave2 ^ 2 >= cav_t2
						then
							nocave = false
						end


						--Now place rocks
						------------------------
						--Place basement rock
						if den_base > t_base then

							--first do ore, with no regard for caves(we want it inside caves)
							if ore(nocave, ab_stra, ab_cave, ab_cave2, y, ORET, ybig, n_strata, data, vi, OREID)
							then
								void = false
							--if it wasn't ore and isn't cave now do rock
							elseif nocave then
								--strata splits..
								local thick = 11 + (3*n_strata)
								local ystrata = math.sin(y/thick)

								--an occassional layer of obsidian around caves
								if (n_cave2 > 0.90 or n_cave > 0.90)
								and ystrata > 0.1 then
									--small chance of minerals from volcanism..
									local roll = math.random(1,1000)
									if roll == 1 then
										data[vi] = OREID.c_gold
										void = false
									elseif roll == 2 then
										data[vi] = OREID.c_copp
										void = false
									elseif roll == 3 then
										data[vi] = OREID.c_tin
										void = false
									elseif roll == 4 then
										data[vi] = OREID.c_mese
										void = false
									else
										data[vi] = c_obsid
										void = false
									end
								--grey stone layer...
								elseif ystrata >= 0 then
									--small chance of some iron
									if math.random(1,1000) == 1 then
										data[vi] = OREID.c_iron
										void = false
									--grey stone
									else
										data[vi] = c_stone
										void = false
									end
								-- red stone layer
								else
									data[vi] = c_stone2
									void = false
								--finished with rocks and ores
								end
							--finished with base nocave
							end
						--finished with base layer
						end

						------------------------
						--Place soft rock
						if void then
							if den_soft > t_base then

								-----------------
								--Caves for soft rock
								local cav_t2 = BCAVT

								if ab_cave2 >= cav_t2
								then
									nocave = false
								end

								--first do ore, with no regard for caves(we want it inside caves)
								if ore(nocave, ab_stra, ab_cave, ab_cave2, y, ORET, ybig, n_strata, data, vi, OREID)
								then
									void = false
								--if it wasn't ore and isn't cave now do rock
								elseif nocave then
									--strata splits..
									local thick = 7 + (2*n_strata)
									local ystrata = math.sin(y/thick)

									--a little lost base rock...
									--with coal and iron
									if ystrata >= 0.7
									and ystrata <= 0.9
									and n_strata > 0.8 then
										if math.random(1,10) == 1 then
											data[vi] = OREID.c_coal
											void = false
										elseif math.random(1,100) == 1 then
											data[vi] = OREID.c_iron
											void = false
										else
											data[vi] = c_stone
											void = false
										end
									--a little more lost base rock...
									--with rare diamonds and mese
									elseif ystrata <= 0.6
									and ystrata >= 0.4
									and n_strata > 0.9 then
										local roll = math.random(1,3000)
										if roll == 1 then
											data[vi] = OREID.c_diam
											void = false
										elseif roll == 2 then
											data[vi] = OREID.c_mese
											void = false
										else
											data[vi] = c_stone2
											void = false
										end
									-- now the actual soft rock
									elseif ystrata >= 0.33 then
										 data[vi] = c_sandstone
										 void = false
									elseif ystrata <= -0.33 then
										 data[vi] = c_sandstone2
										 void = false
									else
										data[vi] = c_sandstone3
										void = false
									--end of placing soft layer stone
									end
								--done with not soft cave
								end
							--finished soft rock
							end
						end


						--------------------------
						--Stability Check
						-- looks at place below the current node.
						-- For those options that require to be placed on top of something
						--We've yet to see proof it's stable
						local stab = false

						if nodu ~= MISCID.c_air
						--and nodu ~= MISCID.c_ignore
						and nodu ~= MISCID.c_water
						and nodu ~= MISCID.c_river
						and nodu ~= c_ice
						then
							--no air, water, or river water... therefore it's stable
							stab = true
						end

						-- the following need to be stable
						--but some solid things are stable..e.g. clay,.
						--... so covers caves, rather than have giant holes
						--allows "clay caves". Height limit or it coats everything in clay
						--only in areas where sediment is higher than base rock (so not coating all caves)
						if not stab
						and den_soft < den_sedi
						and y > (-320 + (n_strata*8))
						--and y < (128 + (n_strata*16))
						then
							if den_sedi > t_base and nocave then
								data[vi] = SEDID.c_clay
								void = false
							end
						elseif stab then

							--Place alluvium
							if void then
								if den_allu > t_base and nocave then

									--strata splits..
									local thick = 31 + (29*n_strata)
									local ystrata = math.sin(y/thick)

									local t1 = 0.4
									local t2 = 0.8

									if ystrata >= 0
									and ystrata < t1 then
										data[vi] = SEDID.c_gravel
										void = false
									elseif ystrata >= t1
									and ystrata < t2 then
										data[vi] = SEDID.c_sand2
										void = false
									elseif ystrata < 0
									and ystrata > -t1 then
										data[vi] = c_dsand
										void = false
									elseif ystrata <= -t1
									and ystrata > -t2 then
										data[vi] = SEDID.c_sand
										void = false
									elseif ystrata <= -t2
									or ystrata >= t2 then
										data[vi] = SEDID.c_clay
										void = false
									end
								end
							--end of alluvium
							end

							---------------------------
							--Subsurface Sediments
							--these are done to match the location

							if void then
								if den_sedi > t_base and nocave then
									--non-basin seas
									if y < SEA-1 then
										data[vi] = SEDID.c_sand
										void = false
									else
										--We are above sea level...	now we need to know climate.
										local temp
										local hum
										local distu
										temp, hum, distu = mgtec.climate(x, z, y, n_terr, n_terr2)

										--We have some fiddly coastal stuff.
										--on a node, that is sea surface or one above
										if y <= SEA + 1 and y >= SEA-1 then
											--a humid place? will make swamps
											if hum > 80  then  --boundary for swamp
												--let's place a swampy mire
												swamp(data, vi, 40, SEDID.c_clay, MISCID.c_river)
												void = false
											elseif hum > 60  then -- less swampy
												swamp(data, vi, 80, SEDID.c_clay, MISCID.c_river)
												void = false
											--wasn't humid . Do dunes
											else
												data[vi] = SEDID.c_sand
												void = false
											end
										-- Not coastal so...
										--lets do Temp/humidity combos
										--polar
									elseif temp < 20 then
											--'Swamp' Polar.. all ice
											if hum > 85 then
												data[vi] = c_ice
												void = false
											-- damp polar... some ice and permafrost
											elseif hum > 60 then
												swamp(data, vi, 50, SEDID.c_perma, c_ice)
												void = false
											-- too dry
											else
												data[vi] = SEDID.c_gravel
												void = false
											end
										--Non polar (not frozen) Swamps
										elseif hum > 80 then
											--disturbed swamps
											if distu > 50 then
												swamp(data, vi, 150, SEDID.c_gravel, MISCID.c_river)
												void = false
											--stable swamps
											else
												swamp(data, vi, 100, SEDID.c_clay, MISCID.c_river)
												void = false
											end
										-- Nonpolar arid
										elseif hum < 20 then
											--sand dunes...?
											data[vi] = c_dsand
											void = false
										--wasn't one of the weirdos. Must be dirt.
										else
											data[vi] = SEDID.c_dirt
											void = false
										--end of climate based sediments
										end
									--done with if sea etc..
									end
								end
							--finished sediments
							end
						--done with stables.

						end

					--finished with not in basin
					end
				--finished with things below rock thresholds.
				end

				--------------------------------
				--Skins


				if void
				and nodu ~= nil
				and nodu ~= MISCID.c_ignore then
					--now we need climate data.
					local temp
					local hum
					local distu
					temp, hum, distu = mgtec.climate(x, z, y, n_terr, n_terr2)

					--ocean
					if y <= SEA-1
					and nodu ~= MISCID.c_air
					and (basin == true or river_basin == true) then
						--floating ice
						if temp < 30 and distu > 6 and distu <40 and y == SEA-1 then
							data[vi] = c_ice
							void = false
							--thicker ice in low disturbance
							if distu < 30 then
								if nodu == MISCID.c_water or nodu == MISCID.c_river then
									--This is nodu: nodu  = data[(vi - ystridevm)]
									--overwrite water
									data[(vi - ystridevm)] = c_ice
									--thicker?
									if distu < 20 then
										if data[(vi - 2*ystridevm)] == MISCID.c_water then
											data[(vi - 2*ystridevm)] = c_ice
											--higher on top
											--can't do ice or it becomes an island!
											if data[(vi + ystridevm)] == MISCID.c_air then
												data[(vi + ystridevm)] = c_snow
											end
											--even thicker
											if distu < 10 then
												if data[(vi - 3*ystridevm)] == MISCID.c_water then
													data[(vi - 3*ystridevm)] = c_ice
												end
												--higher on top
												data[(vi + ystridevm)] = c_snowbl
											end
										end
									end
								end
							end
							--seafloor
						elseif nodu ~= MISCID.c_water
						and nodu ~= MISCID.c_river
						and nodu ~= c_coralo
						and nodu ~= c_coralb
						and nodu ~= MISCID.c_coral_green
						and nodu ~= MISCID.c_coral_pink
						and nodu ~= MISCID.c_coral_cyan
						and nodu ~= MISCID.c_kelpsand
						then
							--corals: low disturbance, warm, shallow
							if not river_basin
							and distu > 12
							and distu < 30
							and temp > 40
							and y <= SEA-3
							and y > SEA - 17
							then
								-- allow stacking coral
								local c = math.random(1,31)
								if c <= 1 then
									data[vi] = MISCID.c_water
									void = false
								elseif c <= 6 then
									data[vi] = c_coralb
									void = false
								elseif c <= 11 then
									data[vi] = c_coralo
									void = false
								--rooted
								elseif c <= 13 then
									data[vi] = MISCID.c_coral_green
									void = false
								elseif c <= 15 then
									data[vi] = MISCID.c_coral_pink
									void = false
								elseif c <= 17 then
									data[vi] = MISCID.c_coral_cyan
									void = false
								else
									data[vi] = c_coral
									void = false
								end
							--kelp: higher disturbance, colder, deeper
							elseif not river_basin
							and math.random()<0.5 --spacing
							and distu < 60
							and distu > 10
							and temp < 80
							then
								--short kelp in shallows
								if y <= SEA-5
								and y > SEA - 7 then
									data[vi] = MISCID.c_kelpsand
									data2[vi] = math.random(3, 4) * 16
									void = false
								elseif y <= SEA-7
								and y > SEA - 9 then
									data[vi] = MISCID.c_kelpsand
									data2[vi] = math.random(4, 6) * 16
									void = false
								elseif y <= SEA-9
								and y > SEA - 24 then
									data[vi] = MISCID.c_kelpsand
									data2[vi] = math.random(6, 8) * 16
									void = false
								end

							--rare short kelp:
							--everywhere needs some sea life
							elseif not river_basin
							and y <= SEA - 5
						 	and y > SEA - 15
							and math.random()<0.1 then
								data[vi] = MISCID.c_kelpsand
								data2[vi] = math.random(3, 4) * 16
								void = false

							--low disturbance do fine sediment
							elseif distu < 5
							and nodu ~= SEDID.c_clay
							and nodu ~= SEDID.c_sand2
							and nodu ~= c_coral
							and nodu ~= c_ice then
								data[vi] = SEDID.c_clay
								void = false
							-- volcanic if rough
							elseif distu > 96 and nodu ~= c_ice then
								local c = math.random(1,10)
								if c > 6 then
									data[vi] = c_obsid
									void = false
								else
									data[vi] = MISCID.c_water
									void = false
								end
							--add sand if above sandstone or other sand
							elseif nodu == c_sandstone
							or nodu == c_sandstone2
							or nodu == c_sandstone3
							or nodu == SEDID.c_sand
							or nodu == c_dsand
							then
								data[vi] = SEDID.c_sand2
								void = false
							--add gravel if above stone
							elseif nodu == c_stone
							or nodu == c_stone2
							or nodu == OREID.c_coal
							or nodu == OREID.c_iron
							or nodu == OREID.c_copp
							or nodu == OREID.c_tin then
								data[vi] = SEDID.c_gravel
								void = false
							end
						end
					end

					--give some stuff for caves...
					--a little gravel and sand, and water. but not everywhere
					if not nocave then
						--only place on stone
						if nodu == c_stone
						or nodu == c_stone2
						or nodu == c_sandstone
						or nodu == c_sandstone2
						or nodu == c_sandstone3  then
							-- in disturbed areas
							if distu > 70 then
								if distu > 99 and y > MAXMAG then
									swamp(data, vi, 40, c_obsid, MISCID.c_lava)
									void = false
								else
									data[vi] = SEDID.c_gravel
									void = false
								end
							--water seep in stable points
						  elseif distu < 40 then
								if hum > 60 then
									swamp(data, vi, 50, SEDID.c_clay, MISCID.c_river)
									void = false
								elseif distu < 10 then
									swamp(data, vi, 150, SEDID.c_gravel, MISCID.c_river)
									void = false
								end
							--ice in cold..
						  elseif temp < 3 then
								data[vi] = c_ice
								void = false
							-- random sand
							elseif n_terr2 > 0 then
								data[vi] = SEDID.c_sand2
								void = false
							end
						end
					end

					--what we have left is skinning the land SURFACE.
					--Check if stable below... all the stuff okay with skinning for most things.
					--doing this rather than stab, becasue that allows stacking
					--also allows it to cover unwanted things (e.g. plants)
					local can_sur = false
					if (nodu == c_ice
					or nodu == SEDID.c_sand2
					or nodu == c_dsand
					or nodu == SEDID.c_sand
					or nodu == SEDID.c_dirt
					or nodu == SEDID.c_perma
					or nodu == c_sandstone
					or nodu == c_sandstone2
					or nodu == c_sandstone3
					or nodu == c_stone
					or nodu == c_stone2
					or nodu == SEDID.c_gravel
					or nodu == SEDID.c_clay
					or nodu == OREID.c_coal
					or nodu == OREID.c_iron
					or nodu == OREID.c_copp
					or nodu == OREID.c_tin
					or nodu == OREID.c_gold
					--or nodu == c_obsid
					or nodu == c_coral)
					then
						can_sur = true
					end

					-- ( remember to ban self stacking where needed..
					--i.e. it is on the can_sur list )
					-- bearing in mind we don't know yet about the ignore nodes.
					if can_sur
					and nodu ~= MISCID.c_ignore
					and nocave
					and y >= SEA then

						--coast

						if y <= SEA + (3*ab_stra) then

							--don't cover coral or own sediments
							if nodu ~= c_coral
							and nodu ~= c_coralb
							and nodu ~= c_coralo
							and nodu ~= SEDID.c_clay
							and nodu ~= SEDID.c_sand
							and nodu ~= SEDID.c_sand2
							--and nodu ~= SEDID.c_dirt
							and nodu ~= SEDID.c_gravel
							and nodu ~= c_ice
							then

								--Swamps
								if hum > 60
								then
									--coast super swampy..
									if hum > 80 then
										--frozen
										--icesheet
										if temp < 3 then
											data[vi] = c_ice
											void = false
											--permafrost
										elseif temp <8 then
											--disturbance gives stones.
											if distu < 50 then
												swamp(data, vi, 10, c_permamoss, c_ice)
												void = false
											else
												swamp(data, vi, 10, c_permastone, c_ice)
												void = false
											end
											--cold
										elseif temp <30 then
											swamp(data, vi, 10, c_dirtsno, MISCID.c_river)
											void = false
											--muddy
										else
											swamp(data, vi, 10, SEDID.c_clay, MISCID.c_river)
											void = false
										end
										--coast swampy..
									elseif hum > 60 then
										--frozen
										--icesheet
										if temp < 3 then
											data[vi] = c_ice
											void = false
											--permafrost
										elseif temp <8 then
											--disturbance gives stones.
											if distu < 50 then
												swamp(data, vi, 25, c_permamoss, c_ice)
												void = false
											else
												swamp(data, vi, 25, c_permastone, c_ice)
												void = false
											end
											--cold
										elseif temp <30 then
											swamp(data, vi, 20, c_dirtsno, MISCID.c_river)
											void = false
											--muddy
										else
											swamp(data, vi, 20, SEDID.c_clay, MISCID.c_river)
											void = false
										end
									end
									--frozen
								elseif temp < 5 and hum > 5 then
									data[vi] = c_ice
									void = false
								--muddy bank
								elseif distu < 5 then
									--eroded bank
									local c = math.random(1,10)
									if c > 3 then
										data[vi] = SEDID.c_clay
										void = false
									else
										data[vi] = SEDID.c_sand
										void = false
									end
								--sandy beach
								elseif distu < 40 then
									data[vi] = SEDID.c_sand
									void = false
								--gravel beach...
								elseif distu < 60 then
									data[vi] = SEDID.c_gravel
									void = false
								--rocky soft...
								elseif distu < 90 then
									data[vi] = c_sandstone2
									void = false
								--rocky...
								elseif distu < 95 then
									data[vi] = c_stone
									void = false
								-- rocky volcanic..
								else
									data[vi] = c_obsid
									void = false
								end
							end

						--Frozen Lands
						elseif temp <15 then
							--don't cover own sediments
							if nodu ~= c_snowbl
							then
								--frozen ice stacks chance
								if temp <3 and math.random(1,6) > 5 then
									data[vi] = c_ice
									void = false
									--frozen ice non-stacking
								elseif temp <6 and nodu ~= c_ice then
									data[vi] = c_ice
									void = false
									--permafrost on lowlands where wet
								elseif temp <8 and temp > 2 and hum > 70 and y < (100 + math.random(-20,20)) then
									--disturbance gives stones.
									if distu < 50 then
										data[vi] = c_permamoss
										void = false
									else
										data[vi] = c_permastone
										void = false
									end
									--snow if cold
								elseif temp <11 then
									data[vi] = c_snowbl
									void = false
								--warmer give dirt
							elseif nodu ~= c_ice then
									data[vi] = c_dirtsno
									void = false
								end
							end

						--Broken lands
						elseif distu >= 99 then
							--only allow on stone
							if (nodu == c_stone
							or nodu == c_stone2
							or nodu == c_sandstone
							or nodu == c_sandstone2
							or nodu == c_sandstone3)
							and nodu ~= c_ice
							then
								--wet slips
								if hum > 80 then
									data[vi] = SEDID.c_clay
									void = false
								--gravel slip
								elseif hum < 30 then
									data[vi] = SEDID.c_gravel
									void = false
								-- stripped to rock warm is red
								elseif temp > 50 and nodu ~= c_stone2 then
									data[vi] = c_stone2
									void = false
								-- stripped to rock cold is grey
								elseif temp <= 50 and nodu ~= c_stone then
									data[vi] = c_stone
									void = false
								-- volcano on hills...
								elseif y > 100 + math.random(-10,10) then
									--stacks
									if math.random(1,3) > 1 then
										data[vi] = c_obsid
										void = false
										--nonstacks
									elseif nodu ~= c_obsid then
										data[vi] = c_obsid
										void = false
									end
								--otherwise dirt
								else
									data[vi] = SEDID.c_dirt
									void = false
								end
							end

						-- Dry barren... (or freaking scorching hot)
						elseif hum <20 or temp > 99 then
							--don't cover own sediments etc
							if nodu ~= c_dsand
							--and nodu ~= SEDID.sand
							and nodu ~= SEDID.c_sand2
							and nodu ~= SEDID.c_gravel
							and nodu ~= c_ice
							and nodu ~= c_snowbl
							then
								-- disturbed and extreme areas stripped to rock
								if distu > 90 then
									data[vi] = SEDID.c_gravel
									void = false
								--cold and dry
							  elseif temp < 30 then
									--very dry places are cold desert
									if hum < 7 then
										data[vi] = SEDID.c_sand2
										void = false
									-- wet enough for soil, still too dry to snow
								  elseif hum < 14 then
										data[vi] = c_dirtdgr
										void = false
									--more water and it snows
									else
										data[vi] = c_dirtsno
										void = false
									end
								--hot and dry
								--desert
								elseif temp >= 80 then
									data[vi] = c_dsand
									void = false
								--temperate
								else
									-- more moisture have soil
									if hum > 6 then
										data[vi] = c_dirtdgr
										void = false
									--very dry (or if in doubt) are gravel
									else
										--data[vi] = OREID.c_mese
										data[vi] = SEDID.c_gravel
										void = false
									end
								end
							end

							--Forests..
							--less disturbance. with enough moisture, not too cold.
						elseif distu < 25 and hum > 30 and temp > 25 and temp < 90 then
							--conifers... cold and dry
							if temp < 40 and hum < 45 then
								data[vi] = c_dirtconlit
								void = false
							--all the others...because that's all we got
							else
								data[vi] = c_dirtlit
								void = false
							end


							--All the rest must be grasslands
						else
							--dry...
							if hum < 40 or temp >90 then
								data[vi] = c_dirtdgr
								void = false
							--cold
						  elseif temp < 30 then
								data[vi] = c_dirtsno
								void = false
								--warm and wet
							else
								data[vi] = c_dirtgr
								void = false
							end

						--end of climate combos
						end
					--end of can sur
					end
				--end of voids
				end

				--Fill the oceans and deeps

				if y < SEA and void then
					if river_basin then
						data[vi] = MISCID.c_river
						void = false
					elseif nocave then
						data[vi] = MISCID.c_water
						void = false
					else
						local magdepth = MAXMAG + (n_terr * 10)
						if y < magdepth then
							--we have lava.
							data[vi] = MISCID.c_lava
							void = false
						end
					end
				end





				-----------------------------------------------
				--Housekeeping before we exit the loop
				-- Increment noise index.
				nixyz = nixyz + 1
				nixz = nixz + 1

				-- Increment voxelmanip index along x row.
			 	-- The voxelmanip index increases by 1 when
			 	-- moving by 1 node in the +x direction.
				vi = vi + 1
			end
			nixz = nixz - sidelen
		end
		nixz = nixz + sidelen
	end
	--We have left the loop!


	-----------------------------------
	--LOOP TWO
	--For decorations etc

	nixz = 1

	for z = minp.z, maxp.z do
	 for y = minp.y, maxp.y do
		 -- Voxelmanip index for the flat array of content IDs.
		 -- Initialise to first node in this x row.
		 local vi = area:index(minp.x, y, z)
		 for x = minp.x, maxp.x do

			 ---------------------------------
			 if y > SEA then

				 --we only go ahead if it's empty
				 if data[vi] == MISCID.c_air then

					 --Substrate, all plants should check it themselves...
					 -- so no need to check here
					 local nodu  = data[(vi - ystridevm)]

					 --We need these again
					 local n_terr  = nvals_terrain[nixz]
					 local n_terr2  = nvals_terrain[nixz]

					 --get climate data
					 local temp
					 local hum
					 local distu
					 temp, hum, distu = mgtec.climate(x, z, y, n_terr, n_terr2)

					 -- pack it in a table, for plants API
					 local conditions = {
															 temp = temp,
															 humidity = hum,
															 disturb = distu,
															 nodu = nodu
															 }
					 local pos = {x = x, y = y, z = z}
					 --call the api... this will create plant
					 mgtec.choose_generate_plant(vm, conditions, pos, data, data2, area, vi)

					 --do snow pack over everything
					if data[vi] == MISCID.c_air
					and nodu ~= MISCID.c_ignore
					and nodu ~= MISCID.c_air
					and hum > 15
					and temp < 30
					and nodu ~= c_snow
					and y >= SEA + 2 then
						local name = minetest.get_name_from_content_id(nodu)

						if not minetest.registered_nodes[name] then
							return nil
						end
						local draw = minetest.registered_nodes[name]['drawtype']

						if draw == 'normal'
						or draw == 'allfaces_optional'  then
							data[vi] = c_snow
						 void = false
					 end
				 end

				 --done with void areas.
				 end
			 --end of not underwater stuff.
			 end


			 ---------------------------
			 --Final Housekeeping
			 -- Increment noise index.
			nixz = nixz + 1
			 -- Increment voxelmanip index along x row.
			vi = vi + 1
		end
		nixz = nixz - sidelen
	end
	nixz = nixz + sidelen
end
	--we have left loop 2...probably isn't the quickest solution, but it works.


	----------------------------------------------------
	--Write to the the Map.

	-- After processing, write content ID data back to the voxelmanip.
	vm:set_data(data)
	vm:set_param2_data(data2)
	-- Calculate lighting for what has been created.
	vm:calc_lighting()
	-- Write what has been created to the world.
	vm:write_to_map()
	-- Liquid nodes were placed so set them flowing.
	vm:update_liquids()

	--------------------------------------------------
	-- Print generation time of this mapchunk.
	local chugent = math.ceil((os.clock() - t0) * 1000)
	print ("[mg_tectonic] Mapchunk generation time " .. chugent .. " ms")

--End of Generation
end))

--===============================================================





-----------------------------------------------------------
--SPAWN PLAYER


--spawnpoints = {} -- We don't want them respawning somewhere else! (That could be interesting, though.)

local function get_far_node(pos, player,alt)
	local node = minetest.get_node(pos)
	if node.name == "ignore" then
	    minetest.emerge_area(pos, pos)
			minetest.after(2,function()
	        spawnplayer(player, alt)
	    end)
	    return node, false
	end
	return node, true
end


function spawnplayer(player,alt)
    local pos = spawnpoint


		--an attempt to reduce time...puts player underground :-(
		--local xtgr_spawn = 1-(math.abs(pos.x)/YMAX)
		--alt = math.floor(alt * xtgr_spawn)

    for i = alt, 0,-1 do
				alt = i
        pos.y = i
				minetest.chat_send_player(player:get_player_name(), "Please wait. The spawning code is looking for the ground. Spawning at... x:"..pos.x.." z:"..pos.z .." y:"..pos.y)
        local node, val = get_far_node(pos, player, alt)
        if not val then
						pos.y = pos.y + 1000
						player:setpos(pos)
            break
        end
        if node.name ~= "air" then
					break
        end
    end

	pos.y = pos.y + 2
	player:setpos(pos)

	--save location
	mod_storage:set_int("x", pos.x)
	mod_storage:set_int("y", pos.y)
	mod_storage:set_int("z", pos.z)

end



function savedspawn(player)
	--get location from storage
	local spx =  mod_storage:get_int("x")
	local spy =  mod_storage:get_int("y")
	local spz =  mod_storage:get_int("z")
	local pos = {x = spx, y = spy, z = spz}

	minetest.chat_send_player(player:get_player_name(), "Respawning at... x:"..spx.." z:"..spz .." y:"..spy)
	player:setpos(pos)
end


-----------------------------------------------------------
minetest.register_on_newplayer(function(player)

	spawnplayer(player,2600)


	-- Get the inventory of the player
	local inventory = player:get_inventory()
	--give them some gear to help in survival mode
	--sometimes spawns in barren places

	--inventory:add_item("main", "default:pick_stone")
	--inventory:add_item("main", "default:torch 15")
	--inventory:add_item("main", "default:ladder 10")
	inventory:add_item("main", "farming:bread 7")
	inventory:add_item("main", "farming:seed_wheat 4")
  inventory:add_item("main", "farming:seed_cotton 4")
	inventory:add_item("main", "default:sapling")
end)


--default clouds are way too low...raise them
local init_cloud = function(player)
	player:set_clouds({color="#FFFFFFFC", density=0.40, height=1500, thickness=25, speed ={x=1, z=0}})
end

--use beds rather than original spawn point
local enable_bed_respawn = minetest.settings:get_bool("enable_bed_respawn")
if enable_bed_respawn == nil then
	enable_bed_respawn = true
end


--this is needed to stop it putting player at 0,0,0...but overrides bed save :-(
minetest.register_on_respawnplayer(function(player)
	init_cloud(player)
	-- Avoid respawn conflict with beds mod
	if beds
	and enable_bed_respawn
	and	beds.spawn[player:get_player_name()] then
		return
	end

	savedspawn(player)
	--disable default
	return true
end)


minetest.register_on_joinplayer(init_cloud)

---------------------------------------
--Bug testing Climate tool
--need to give n_terr etc or gives inaccurate reading,
-- and blend gives a random margin of error
--[[
local enviro_meter = function(user, pointed_thing)

  local name =user:get_player_name()
  local pos = user:getpos()

	minetest.chat_send_player(name, minetest.colorize("#00ff00", "ENVIRONMENT MEASUREMENT:"))

  local t,h,d = mgtec.climate(pos.x, pos.z, pos.y)

  minetest.chat_send_player(name, minetest.colorize("#cc6600","TEMPERATURE INDEX LEVEL = "..t))
	minetest.chat_send_player(name, minetest.colorize("#cc6600","HUMIDITY INDEX LEVEL = "..h))
	minetest.chat_send_player(name, minetest.colorize("#cc6600","DISTURBANCE INDEX LEVEL = "..d))


end


minetest.register_craftitem("mg_tectonic:enviro_meter", {
	description = "Enviro Meter",
	inventory_image = "default_paper.png",
	stack_max = 1,

	on_use = function(itemstack, user, pointed_thing)
		enviro_meter(user, pointed_thing)
	end,
})
]]