Terain_Ext, Lua - rextester

Language: Layout:

local mapgenutil = require "terrain/mapgenutil"
local temperateassetsgen = require "terrain/temperateassetsgen"
local layersutil = require "terrain/layersutil"
local maputil = require "maputil"

function data()

return {
	climate = "temperate.clima.lua",
	order = 0,
	name = _("Temperate (extended)"),
	params = {                
		{
			key = "hilliness",
			name = _("Terrain height difference"),
			values = { "", "", "", "", "", "", "", "", "" },
			defaultIndex = 2,
			uiType = "SLIDER",
		},
                {
			key = "noise",
			name = _("Terrain roughness"),
			values = { "", "", "", "", "", "", "", "", "", "", "" },
			defaultIndex = 5,
			uiType = "SLIDER",
		},
                {
			key = "ridge_density",
			name = _("Mountain ridges"),
			values = { "", "", "", "", "", "", "" },
			defaultIndex = 2,
			uiType = "SLIDER",
		},   
                {
			key = "ridge_min_height",
			name = _("Ridge min. height"),
			values = { "", "", "", "", "", "", "", "" },
			defaultIndex = 1,
			uiType = "SLIDER",
		},  
                {
			key = "ridge_max_height",
			name = _("Ridge max. height"),
			values = { "", "", "", "", "", "", "", "" },
			defaultIndex = 3,
			uiType = "SLIDER",
		},                 
		{
			key = "water",
			name = _("Rivers: Water quantity"),
			values = { "", "", "", "", "", "", "", "" },
			defaultIndex = 2,
			uiType = "SLIDER",
		},
                {
			key = "seglength",
			name = _("Rivers: Straightness"),
			values = { "", "", "", "", "", "", "", "", "" },
			defaultIndex = 5,
			uiType = "SLIDER",
		},
                {
			key = "order",
			name = _("Rivers: Forks"),
			values = { "", "", "", "", "" },
			defaultIndex = 2,
			uiType = "SLIDER",
		},
                {
			key = "lakes",
			name = _("Rivers: Lakes"),
			values = { "", "", "", "", "", "", "", "", "", "" },
			defaultIndex = 3,
			uiType = "SLIDER",
		},
                {
			key = "lakesize",
			name = _("Rivers: Lake size"),
			values = { "", "", "", "", "", "", "", "", "", "" },
			defaultIndex = 2,
			uiType = "SLIDER",
		},		
		{
			key = "forest",
			name = _("Forest"),
			values = { "", "", "", "", "", "", "", "", "", "", "" },
			defaultIndex = 3,
			uiType = "SLIDER",
		},
                {
			key = "tree_limit",
			name = _("Timber line"),
			values = { "", "", "", "", "", "", "", "" },
			defaultIndex = 5,
			uiType = "SLIDER",
		},
	},
	updateFn = function(params)
		-- local temperateassetsgen = dofile("./res/scripts/terrain/temperateassetsgen.lua")
		-- local mapgenutil = dofile("./res/scripts/terrain/mapgenutil.lua")
		-- local layersutil = dofile("./res/scripts/terrain/layersutil.lua")
		local result = {
			parallelFactor = 32,
			heightmapLayer = "HM",
			layers = layersutil.Layer.new(),
		}

local sameSeed = math.random(1, 100000000)
		math.randomseed(sameSeed) -- reset seed to match desert generator
		
		-- #################
		-- #### CONFIG
		local hillyness = params.hilliness / 8
                local ridge_density = params.ridge_density
                local ridge_min_height = params.ridge_min_height * 40
                local ridge_max_height = params.ridge_max_height * 40
		local water = params.water / 4
		local order = params.order
                local segment_length = (params.seglength + 1) * 400
                local lakes = params.lakes / 9
		local lake_size = (params.lakesize + 1) / 4
		local humidity = params.forest / 7

local noWater = water == 0
		
		local riverConfig = {
			depthScale = 1.5,
			maxOrder = order,
			segmentLength = segment_length,
			bounds = params.bounds,
			baseProbability = water * water * 2,
			minDist = water > 0.5 and 2 or 3,
		}
		
		local rivers = {}
		if not noWater then
			local start = mapgenutil.FindGoodRiverStart(params.bounds)
			mapgenutil.MakeRivers(rivers, riverConfig, 120000, start.pos, start.angle)
			
			local lakeProb1 = water > 0.2 and 0.2 or 0 -- math.map(water, 0, 1, 0.0, 0.1)
			local lakeProb2 = water > 0.2 and 0.4 or 0.9 -- math.map(water, 0, 1, 0.1, 0.1)
			local lakeConfig = {
				getLakePropability = function()
					return lakes
				end,
				lakeSize = lake_size * 600, 
			}
			mapgenutil.MakeLakesOld(rivers, lakeConfig)
			
			-- local curvesConfig = {
				-- getStrength = function(position) 
					-- return 0.7
				-- end,
				-- getWidthMultiplier = function(position) 
					-- return 1
				-- end
			-- }
			-- mapgenutil.MakeCurvesOld(rivers, curvesConfig)
			
			maputil.Convert(rivers)
			maputil.ValidateRiver(rivers)
			-- maputil.PrintRiver(rivers) 
		end
	
		local ridgesConfig = {
			bounds = params.bounds, 
			-- probabilityLow = 0.3 + 0.7 * hillyness,
			-- probabilityHigh = 0.5 + 0.5 * hillyness,
                        density = ridge_density,			
			-- minHeight = 0 + 80 * hillyness, 
			-- maxHeight = 75 + 100 * hillyness,
                        minHeight = ridge_min_height, 
			maxHeight = ridge_max_height,
		}

local valleys = {}
		local ridges = mapgenutil.MakeRidges(ridgesConfig)
		
		-- #################
		-- #### PREPARE
		local mkTemp = layersutil.TempMaker.new()
		
		-- #################
		-- #### BACKGROUND AND RIVER
		result.layers:Constant(result.heightmapLayer, .01)
		
		do -- river
			result.layers:PushColor("#0022DD")
			result.layers:River(result.heightmapLayer, rivers)
			result.layers:PopColor()
		end
		
		local noiseMap = mkTemp:Get()
		result.layers:Noise(noiseMap, 150 * hillyness)
		
		local distanceMap = mkTemp:Get()
		result.layers:Distance(result.heightmapLayer, distanceMap)
		
		-- #################
		-- #### RIDGES
		local ridgesMap
		do -- ridges
			result.layers:PushColor("#22AADD")
			local t1 = mkTemp:Get()
			result.layers:Map(distanceMap, t1, {15, 2500}, {0, 1}, true)
			result.layers:Mad(t1, noiseMap, result.heightmapLayer)
			noiseMap = mkTemp:Restore(noiseMap)
			
			local t2 = mkTemp:Get()
			result.layers:Ridge(t2, {
				valleys = valleys.points,
				ridges = ridges,
				noiseStrength = 10
			})
			
			result.layers:Map(distanceMap, t1, {50, 1500}, {0, 1}, true)
			ridgesMap = mkTemp:Get()
			result.layers:Mul(t1, t2, ridgesMap)
			t1 = mkTemp:Restore(t1)
			t2 = mkTemp:Restore(t2)

result.layers:Add(ridgesMap, result.heightmapLayer, result.heightmapLayer)
			result.layers:PopColor()
		end
		
		-- #################
		-- #### NOISE
		-- local noiseStrength = 25.7
                local noiseStrength = params.noise * 5
		local addNoise = true
		if addNoise then
			result.layers:PushColor("#5577DD")
			local t2 = mkTemp:Get()
			result.layers:RidgedNoise(t2, { octaves = 5, frequency = 1 / 444, lacunarity = 2.2, gain = 0.8 } )
			result.layers:Map(t2, t2, {0, 4}, {0, noiseStrength * 1.2}, false)
			
			local t1 = mkTemp:Get()
			result.layers:Map(distanceMap, t1, {0, 30}, {0, 1}, true)
			
			result.layers:Mad(t2, t1, result.heightmapLayer)
			mkTemp:Restore(t1)
			mkTemp:Restore(t2)
			result.layers:PopColor()
		end
		
		-- #################
		-- #### ASSETS

local tree_limit = params.tree_limit * 30

local config = {}

if humidity == 0 then

config =  {
				-- GENERIC
				humidity = -1,
				water = water,
				-- LEVEL 3
				hillsLowLimit = 0, -- relative [m]
				hillsLowTransition = 0, -- relative [m]
				-- LEVEL 4
				treeLimit = 0, -- absolute [m] (absolute maximal height)
				ridgeFactor = 0, -- lower means softer ridges detection, more trees (0.8)
				valleyFactor = 0, -- lower means softer valleys detection, more trees (0.8)
			}

else

config =  {
				-- GENERIC
				humidity = humidity / 2.5,
				water = water,
				-- LEVEL 3
				hillsLowLimit = 20, -- relative [m]
				hillsLowTransition = 20, -- relative [m]
				-- LEVEL 4
				treeLimit = tree_limit, -- absolute [m] (absolute maximal height)
				ridgeFactor = 0.6, -- lower means softer ridges detection, more trees (0.8)
				valleyFactor = 0.6, -- lower means softer valleys detection, more trees (0.8)
			}

end

result.layers:PushColor("#007777")
		result.forestMap, result.treesMapping, result.assetsMap, result.assetsMapping = temperateassetsgen.Make(
		 	result.layers, config, mkTemp, result.heightmapLayer, ridgesMap, distanceMap
		)
		result.layers:PopColor()

distanceMap = nil
	
		-- #################
		-- #### FINISH
		ridgesMap = mkTemp:Restore(ridgesMap)
		mkTemp:Restore(result.forestMap)
		mkTemp:Restore(result.assetsMap)
		mkTemp:Finish()
		-- maputil.PrintGraph(result)
	
		return result
	end
}

end

[ + ] Show input
Absolute running time: 0.14 sec, cpu time: 0 sec, memory peak: 3 Mb, absolute service time: 0,14 sec