Index: ps/trunk/binaries/data/mods/public/maps/random/rmgen/library.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/rmgen/library.js	(revision 20788)
+++ ps/trunk/binaries/data/mods/public/maps/random/rmgen/library.js	(revision 20789)
@@ -1,527 +1,517 @@
 const PI = Math.PI;
 const TWO_PI = 2 * Math.PI;
 const TERRAIN_SEPARATOR = "|";
 const SEA_LEVEL = 20.0;
 const HEIGHT_UNITS_PER_METRE = 92;
 const MAP_BORDER_WIDTH = 3;
 
 const g_DamageTypes = new DamageTypes();
 
 /**
  * Constants needed for heightmap_manipulation.js
  */
 const MAX_HEIGHT_RANGE = 0xFFFF / HEIGHT_UNITS_PER_METRE; // Engine limit, Roughly 700 meters
 const MIN_HEIGHT = - SEA_LEVEL;
 
 /**
  * Length of one tile of the terrain grid in metres.
  * Useful to transform footprint sizes of templates to the coordinate system used by getMapSize.
  */
 const TERRAIN_TILE_SIZE = Engine.GetTerrainTileSize();
 
 const MAX_HEIGHT = MAX_HEIGHT_RANGE - SEA_LEVEL;
 // Default angle for buildings
 const BUILDING_ORIENTATION = - PI / 4;
 
 const g_CivData = deepfreeze(loadCivFiles(false));
 
 function fractionToTiles(f)
 {
 	return g_Map.size * f;
 }
 
 function tilesToFraction(t)
 {
 	return t / g_Map.size;
 }
 
 function fractionToSize(f)
 {
 	return getMapArea() * f;
 }
 
 function sizeToFraction(s)
 {
 	return s / getMapArea();
 }
 
 function scaleByMapSize(min, max, minMapSize = 128, maxMapSize = 512)
 {
 	return min + (max - min) * (g_Map.size - minMapSize) / (maxMapSize - minMapSize);
 }
 
 function cos(x)
 {
 	return Math.cos(x);
 }
 
 function sin(x)
 {
 	return Math.sin(x);
 }
 
 function abs(x) {
 	return Math.abs(x);
 }
 
 function round(x)
 {
 	return Math.round(x);
 }
 
-function lerp(a, b, t)
-{
-	return a + (b-a) * t;
-}
-
 function sqrt(x)
 {
 	return Math.sqrt(x);
 }
 
-function ceil(x)
-{
-	return Math.ceil(x);
-}
-
 function floor(x)
 {
 	return Math.floor(x);
 }
 
 function max(a, b)
 {
 	return a > b ? a : b;
 }
 
 function min(a, b)
 {
 	return a < b ? a : b;
 }
 
 /**
  * Retries the given function with those arguments as often as specified.
  */
 function retryPlacing(placeFunc, retryFactor, amount, getResult, behaveDeprecated = false)
 {
 	let maxFail = amount * retryFactor;
 
 	let results = [];
 	let good = 0;
 	let bad = 0;
 
 	while (good < amount && bad <= maxFail)
 	{
 		let result = placeFunc();
 
 		if (result !== undefined || behaveDeprecated)
 		{
 			++good;
 			if (getResult)
 				results.push(result);
 		}
 		else
 			++bad;
 	}
 	return getResult ? results : good;
 }
 
 /**
  * Sets the x and z property of the given object (typically a Placer or Group) to a random point on the map.
  * @param passableOnly - Should be true for entity placement and false for terrain or elevation operations.
  */
 function randomizeCoordinates(obj, passableOnly)
 {
 	let border = passableOnly ? MAP_BORDER_WIDTH : 0;
 	if (g_MapSettings.CircularMap)
 	{
 		// Polar coordinates
 		// Uniformly distributed on the disk
 		let halfMapSize = g_Map.size / 2 - border;
 		let r = halfMapSize * Math.sqrt(randFloat(0, 1));
 		let theta = randFloat(0, 2 * Math.PI);
 		obj.x = Math.floor(r * Math.cos(theta)) + halfMapSize;
 		obj.z = Math.floor(r * Math.sin(theta)) + halfMapSize;
 	}
 	else
 	{
 		// Rectangular coordinates
 		obj.x = randIntExclusive(border, g_Map.size - border);
 		obj.z = randIntExclusive(border, g_Map.size - border);
 	}
 }
 
 /**
  * Sets the x and z property of the given JS object (typically a Placer or Group) to a random point of the area.
  */
 function randomizeCoordinatesFromAreas(obj, areas)
 {
 	let pt = pickRandom(pickRandom(areas).points);
 	obj.x = pt.x;
 	obj.z = pt.z;
 }
 
 // TODO this is a hack to simulate the old behaviour of those functions
 // until all old maps are changed to use the correct version of these functions
 function createObjectGroupsDeprecated(group, player, constraint, amount, retryFactor = 10)
 {
 	return createObjectGroups(group, player, constraint, amount, retryFactor, true);
 }
 
 function createObjectGroupsByAreasDeprecated(group, player, constraint, amount, retryFactor, areas)
 {
 	return createObjectGroupsByAreas(group, player, constraint, amount, retryFactor, areas, true);
 }
 
 /**
  * Attempts to place the given number of areas in random places of the map.
  * Returns actually placed areas.
  */
 function createAreas(centeredPlacer, painter, constraint, amount, retryFactor = 10)
 {
 	let placeFunc = function() {
 		randomizeCoordinates(centeredPlacer, false);
 		return createArea(centeredPlacer, painter, constraint);
 	};
 
 	return retryPlacing(placeFunc, retryFactor, amount, true, false);
 }
 
 /**
  * Attempts to place the given number of areas in random places of the given areas.
  * Returns actually placed areas.
  */
 function createAreasInAreas(centeredPlacer, painter, constraint, amount, retryFactor, areas)
 {
 	let placeFunc = function() {
 		randomizeCoordinatesFromAreas(centeredPlacer, areas);
 		return createArea(centeredPlacer, painter, constraint);
 	};
 
 	return retryPlacing(placeFunc, retryFactor, amount, true, false);
 }
 
 /**
  * Attempts to place the given number of groups in random places of the map.
  * Returns the number of actually placed groups.
  */
 function createObjectGroups(group, player, constraint, amount, retryFactor = 10, behaveDeprecated = false)
 {
 	let placeFunc = function() {
 		randomizeCoordinates(group, true);
 		return createObjectGroup(group, player, constraint);
 	};
 
 	return retryPlacing(placeFunc, retryFactor, amount, false, behaveDeprecated);
 }
 
 /**
  * Attempts to place the given number of groups in random places of the given areas.
  * Returns the number of actually placed groups.
  */
 function createObjectGroupsByAreas(group, player, constraint, amount, retryFactor, areas, behaveDeprecated = false)
 {
 	let placeFunc = function() {
 		randomizeCoordinatesFromAreas(group, areas);
 		return createObjectGroup(group, player, constraint);
 	};
 
 	return retryPlacing(placeFunc, retryFactor, amount, false, behaveDeprecated);
 }
 
 function createTerrain(terrain)
 {
 	if (!(terrain instanceof Array))
 		return createSimpleTerrain(terrain);
 
 	return new RandomTerrain(terrain.map(t => createTerrain(t)));
 }
 
 function createSimpleTerrain(terrain)
 {
 	if (typeof(terrain) != "string")
 		throw new Error("createSimpleTerrain expects string as input, received " + uneval(terrain));
 
 	// Split string by pipe | character, this allows specifying terrain + tree type in single string
 	let params = terrain.split(TERRAIN_SEPARATOR, 2);
 
 	if (params.length != 2)
 		return new SimpleTerrain(terrain);
 
 	return new SimpleTerrain(params[0], params[1]);
 }
 
 function placeObject(x, z, type, player, angle)
 {
 	if (g_Map.validT(x, z))
 		g_Map.addObject(new Entity(type, player, x, z, angle));
 }
 
 function placeTerrain(x, z, terrainNames)
 {
 	createTerrain(terrainNames).place(x, z);
 }
 
 function initTerrain(terrainNames)
 {
 	let terrain = createTerrain(terrainNames);
 
 	for (let x = 0; x < getMapSize(); ++x)
 		for (let z = 0; z < getMapSize(); ++z)
 			terrain.place(x, z);
 }
 
 function isCircularMap()
 {
 	return !!g_MapSettings.CircularMap;
 }
 
 function getMapBaseHeight()
 {
 	return g_MapSettings.BaseHeight;
 }
 
 function createTileClass()
 {
 	return g_Map.createTileClass();
 }
 
 function getTileClass(id)
 {
 	if (!g_Map.validClass(id))
 		return undefined;
 
 	return g_Map.tileClasses[id];
 }
 
 /**
  * Constructs a new Area shaped by the Placer meeting the Constraint and calls the Painters there.
  * Supports both Centered and Non-Centered Placers.
  */
 function createArea(placer, painter, constraint)
 {
 	if (!constraint)
 		constraint = new NullConstraint();
 	else if (constraint instanceof Array)
 		constraint = new AndConstraint(constraint);
 
 	let points = placer.place(constraint);
 	if (!points)
 		return undefined;
 
 	let area = g_Map.createArea(points);
 
 	if (painter instanceof Array)
 		painter = new MultiPainter(painter);
 
 	painter.paint(area);
 
 	return area;
 }
 
 /**
  * @param mode is one of the HeightPlacer constants determining whether to exclude the min/max elevation.
  */
 function paintTerrainBasedOnHeight(minHeight, maxHeight, mode, terrain)
 {
 	createArea(
 		new HeightPlacer(mode, minHeight, maxHeight),
 		new TerrainPainter(terrain));
 }
 
 function paintTileClassBasedOnHeight(minHeight, maxHeight, mode, tileClass)
 {
 	createArea(
 		new HeightPlacer(mode, minHeight, maxHeight),
 		new TileClassPainter(getTileClass(tileClass)));
 }
 
 function unPaintTileClassBasedOnHeight(minHeight, maxHeight, mode, tileClass)
 {
 	createArea(
 		new HeightPlacer(mode, minHeight, maxHeight),
 		new TileClassUnPainter(getTileClass(tileClass)));
 }
 
 /**
  * Places the Entities of the given Group if they meet the Constraint
  * and sets the given player as the owner.
  */
 function createObjectGroup(group, player, constraint)
 {
 	if (!constraint)
 		constraint = new NullConstraint();
 	else if (constraint instanceof Array)
 		constraint = new AndConstraint(constraint);
 
 	return group.place(player, constraint);
 }
 
 function getMapSize()
 {
 	return g_Map.size;
 }
 
 function getMapArea()
 {
 	return Math.square(g_Map.size);
 }
 
 function getMapCenter()
 {
 	return deepfreeze(new Vector2D(g_Map.size / 2, g_Map.size / 2));
 }
 
 function getNumPlayers()
 {
 	return g_MapSettings.PlayerData.length - 1;
 }
 
 function getCivCode(playerID)
 {
 	return g_MapSettings.PlayerData[playerID].Civ;
 }
 
 function areAllies(playerID1, playerID2)
 {
 	return (
 		g_MapSettings.PlayerData[playerID1].Team !== undefined &&
 		g_MapSettings.PlayerData[playerID2].Team !== undefined &&
 		g_MapSettings.PlayerData[playerID1].Team != -1 &&
 		g_MapSettings.PlayerData[playerID2].Team != -1 &&
 		g_MapSettings.PlayerData[playerID1].Team === g_MapSettings.PlayerData[playerID2].Team);
 }
 
 function getPlayerTeam(playerID)
 {
 	if (g_MapSettings.PlayerData[playerID].Team === undefined)
 		return -1;
 
 	return g_MapSettings.PlayerData[playerID].Team;
 }
 
 function getHeight(x, z)
 {
 	return g_Map.getHeight(x, z);
 }
 
 function setHeight(x, z, height)
 {
 	g_Map.setHeight(x, z, height);
 }
 
 function initHeight(height)
 {
 	g_Map.initHeight(height);
 }
 
 /**
  *	Utility functions for classes
  */
 
 /**
  * Add point to given class by id
  */
 function addToClass(x, z, id)
 {
 	let tileClass = getTileClass(id);
 
 	if (tileClass !== null)
 		tileClass.add(x, z);
 }
 
 /**
  * Remove point from the given class by id
  */
 function removeFromClass(x, z, id)
 {
 	let tileClass = getTileClass(id);
 
 	if (tileClass !== null)
 		tileClass.remove(x, z);
 }
 
 /**
  * Create a painter for the given class
  */
 function paintClass(id)
 {
 	return new TileClassPainter(getTileClass(id));
 }
 
 /**
  * Create a painter for the given class
  */
 function unPaintClass(id)
 {
 	return new TileClassUnPainter(getTileClass(id));
 }
 
 /**
  * Create an avoid constraint for the given classes by the given distances
  */
 function avoidClasses(/*class1, dist1, class2, dist2, etc*/)
 {
 	let ar = [];
 	for (let i = 0; i < arguments.length/2; ++i)
 		ar.push(new AvoidTileClassConstraint(arguments[2*i], arguments[2*i+1]));
 
 	// Return single constraint
 	if (ar.length == 1)
 		return ar[0];
 
 	return new AndConstraint(ar);
 }
 
 /**
  * Create a stay constraint for the given classes by the given distances
  */
 function stayClasses(/*class1, dist1, class2, dist2, etc*/)
 {
 	let ar = [];
 	for (let i = 0; i < arguments.length/2; ++i)
 		ar.push(new StayInTileClassConstraint(arguments[2*i], arguments[2*i+1]));
 
 	// Return single constraint
 	if (ar.length == 1)
 		return ar[0];
 
 	return new AndConstraint(ar);
 }
 
 /**
  * Create a border constraint for the given classes by the given distances
  */
 function borderClasses(/*class1, idist1, odist1, class2, idist2, odist2, etc*/)
 {
 	let ar = [];
 	for (let i = 0; i < arguments.length/3; ++i)
 		ar.push(new BorderTileClassConstraint(arguments[3*i], arguments[3*i+1], arguments[3*i+2]));
 
 	// Return single constraint
 	if (ar.length == 1)
 		return ar[0];
 
 	return new AndConstraint(ar);
 }
 
 /**
  * Checks if the given tile is in class "id"
  */
 function checkIfInClass(x, z, id)
 {
 	let tileClass = getTileClass(id);
 	if (tileClass === null)
 		return 0;
 
 	let members = tileClass.countMembersInRadius(x, z, 1);
 	if (members === null)
 		return 0;
 
 	return members;
 }
 
 function getTerrainTexture(x, y)
 {
 	return g_Map.getTexture(x, y);
 }
Index: ps/trunk/binaries/data/mods/public/maps/random/rmgen/placer_centered.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/rmgen/placer_centered.js	(revision 20788)
+++ ps/trunk/binaries/data/mods/public/maps/random/rmgen/placer_centered.js	(revision 20789)
@@ -1,261 +1,261 @@
 /**
  * @file A Centered Placer generates a shape (array of points) around a variable center location satisfying a Constraint.
  * The center is determined by the x and z property which can be modified externally, typically by createAreas.
  */
 
 /////////////////////////////////////////////////////////////////////////////////////////
 //	ClumpPlacer
 //
 //	Class for generating a roughly circular clump of points
 //
 //	size: The average number of points in the clump
 //	coherence: How much the radius of the clump varies (1.0 = circle, 0.0 = very random)
 //	smoothness: How smooth the border of the clump is (1.0 = few "peaks", 0.0 = very jagged)
 //	failfraction: Percentage of place attempts allowed to fail (optional)
 //	x, z: Tile coordinates of placer center (optional)
 //
 /////////////////////////////////////////////////////////////////////////////////////////
 
 function ClumpPlacer(size, coherence, smoothness, failFraction, x, z)
 {
 	this.size = size;
 	this.coherence = coherence;
 	this.smoothness = smoothness;
 	this.failFraction = failFraction !== undefined ? failFraction : 0;
 	this.x = x !== undefined ? x : -1;
 	this.z = z !== undefined ? z : -1;
 }
 
 ClumpPlacer.prototype.place = function(constraint)
 {
 	// Preliminary bounds check
 	if (!g_Map.inMapBounds(this.x, this.z) || !constraint.allows(this.x, this.z))
 		return undefined;
 
 	var retVec = [];
 
 	var size = getMapSize();
 	var gotRet = new Array(size).fill(0).map(p => new Uint8Array(size)); // booleans
 	var radius = sqrt(this.size / PI);
 	var perim = 4 * radius * 2 * PI;
-	var intPerim = ceil(perim);
+	var intPerim = Math.ceil(perim);
 
 	var ctrlPts = 1 + Math.floor(1.0/Math.max(this.smoothness,1.0/intPerim));
 
 	if (ctrlPts > radius * 2 * PI)
 		ctrlPts = Math.floor(radius * 2 * PI) + 1;
 
 	var noise = new Float32Array(intPerim);			//float32
 	var ctrlCoords = new Float32Array(ctrlPts+1);	//float32
 	var ctrlVals = new Float32Array(ctrlPts+1);		//float32
 
 	// Generate some interpolated noise
 	for (var i=0; i < ctrlPts; i++)
 	{
 		ctrlCoords[i] = i * perim / ctrlPts;
 		ctrlVals[i] = randFloat(0, 2);
 	}
 
 	var c = 0;
 	var looped = 0;
 	for (var i=0; i < intPerim; i++)
 	{
 		if (ctrlCoords[(c+1) % ctrlPts] < i && !looped)
 		{
 			c = (c+1) % ctrlPts;
 			if (c == ctrlPts-1)
 				looped = 1;
 		}
 
 		noise[i] = cubicInterpolation(
 			1,
 			(i - ctrlCoords[c]) / ((looped ? perim : ctrlCoords[(c + 1) % ctrlPts]) - ctrlCoords[c]),
 			ctrlVals[(c + ctrlPts - 1) % ctrlPts],
 			ctrlVals[c],
 			ctrlVals[(c + 1) % ctrlPts],
 			ctrlVals[(c + 2) % ctrlPts]);
 	}
 
 	var failed = 0;
 	for (var p=0; p < intPerim; p++)
 	{
 		var th = 2 * PI * p / perim;
 		var r = radius * (1 + (1-this.coherence)*noise[p]);
 		var s = sin(th);
 		var c = cos(th);
 		var xx = this.x;
 		var yy = this.z;
 
-		for (var k=0; k < ceil(r); k++)
+		for (var k = 0; k < Math.ceil(r); ++k)
 		{
 			var i = Math.floor(xx);
 			var j = Math.floor(yy);
 			if (g_Map.inMapBounds(i, j) && constraint.allows(i, j))
 			{
 				if (!gotRet[i][j])
 				{
 					// Only include each point once
 					gotRet[i][j] = 1;
 					retVec.push({ "x": i, "z": j });
 				}
 			}
 			else
 				failed++;
 
 			xx += s;
 			yy += c;
 		}
 	}
 
 	return failed > this.size * this.failFraction ? undefined : retVec;
 };
 
 /////////////////////////////////////////////////////////////////////////////////////////
 //	Chain Placer
 //
 //	Class for generating a more random clump of points it randomly creates circles around the edges of the current clump
 //
 //	minRadius: minimum radius of the circles
 //	maxRadius: maximum radius of the circles
 //	numCircles: the number of the circles
 //	failfraction: Percentage of place attempts allowed to fail (optional)
 //	x, z: Tile coordinates of placer center (optional)
 //  fcc: Farthest circle center (optional)
 //  q: a list containing numbers. each time if the list still contains values, pops one from the end and uses it as the radius (optional)
 //
 /////////////////////////////////////////////////////////////////////////////////////////
 
 function ChainPlacer(minRadius, maxRadius, numCircles, failFraction, x, z, fcc, q)
 {
 	this.minRadius = minRadius;
 	this.maxRadius = maxRadius;
 	this.numCircles = numCircles;
 	this.failFraction = failFraction !== undefined ? failFraction : 0;
 	this.x = x !== undefined ? x : -1;
 	this.z = z !== undefined ? z : -1;
 	this.fcc = fcc !== undefined ? fcc : 0;
 	this.q = q !== undefined ? q : [];
 }
 
 ChainPlacer.prototype.place = function(constraint)
 {
 	// Preliminary bounds check
 	if (!g_Map.inMapBounds(this.x, this.z) || !constraint.allows(this.x, this.z))
 		return undefined;
 
 	var retVec = [];
 	var size = getMapSize();
 	var failed = 0, count = 0;
 	var queueEmpty = !this.q.length;
 
 	var gotRet = new Array(size).fill(0).map(p => new Array(size).fill(-1));
 	--size;
 
 	this.minRadius = Math.min(this.maxRadius, Math.max(this.minRadius, 1));
 
 	var edges = [[this.x, this.z]];
 	for (var i = 0; i < this.numCircles; ++i)
 	{
 		var [cx, cz] = pickRandom(edges);
 		if (queueEmpty)
 			var radius = randIntInclusive(this.minRadius, this.maxRadius);
 		else
 		{
 			var radius = this.q.pop();
 			queueEmpty = !this.q.length;
 		}
 
 		var sx = cx - radius, lx = cx + radius;
 		var sz = cz - radius, lz = cz + radius;
 
 		sx = Math.max(0, sx);
 		sz = Math.max(0, sz);
 		lx = Math.min(lx, size);
 		lz = Math.min(lz, size);
 
 		var radius2 = radius * radius;
 		var dx, dz;
 
 		for (var ix = sx; ix <= lx; ++ix)
 			for (var iz = sz; iz <= lz; ++ iz)
 			{
 				dx = ix - cx;
 				dz = iz - cz;
 				if (dx * dx + dz * dz <= radius2)
 				{
 					if (g_Map.inMapBounds(ix, iz) && constraint.allows(ix, iz))
 					{
 						var state = gotRet[ix][iz];
 						if (state == -1)
 						{
 							retVec.push({ "x": ix, "z": iz });
 							gotRet[ix][iz] = -2;
 						}
 						else if (state >= 0)
 						{
 							var s = edges.splice(state, 1);
 							gotRet[ix][iz] = -2;
 
 							var edgesLength = edges.length;
 							for (var k = state; k < edges.length; ++k)
 								--gotRet[edges[k][0]][edges[k][1]];
 						}
 					}
 					else
 						++failed;
 
 					++count;
 				}
 			}
 
 		for (var ix = sx; ix <= lx; ++ix)
 			for (var iz = sz; iz <= lz; ++ iz)
 			{
 				if (this.fcc)
 					if ((this.x - ix) > this.fcc || (ix - this.x) > this.fcc || (this.z - iz) > this.fcc || (iz - this.z) > this.fcc)
 						continue;
 
 				if (gotRet[ix][iz] == -2)
 				{
 					if (ix > 0)
 					{
 						if (gotRet[ix-1][iz] == -1)
 						{
 							edges.push([ix, iz]);
 							gotRet[ix][iz] = edges.length - 1;
 							continue;
 						}
 					}
 					if (iz > 0)
 					{
 						if (gotRet[ix][iz-1] == -1)
 						{
 							edges.push([ix, iz]);
 							gotRet[ix][iz] = edges.length - 1;
 							continue;
 						}
 					}
 					if (ix < size)
 					{
 						if (gotRet[ix+1][iz] == -1)
 						{
 							edges.push([ix, iz]);
 							gotRet[ix][iz] = edges.length - 1;
 							continue;
 						}
 					}
 					if (iz < size)
 					{
 						if (gotRet[ix][iz+1] == -1)
 						{
 							edges.push([ix, iz]);
 							gotRet[ix][iz] = edges.length - 1;
 							continue;
 						}
 					}
 				}
 			}
 	}
 
 	return failed > count * this.failFraction ? undefined : retVec;
 };
Index: ps/trunk/binaries/data/mods/public/maps/random/wild_lake.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/wild_lake.js	(revision 20788)
+++ ps/trunk/binaries/data/mods/public/maps/random/wild_lake.js	(revision 20789)
@@ -1,651 +1,651 @@
 Engine.LoadLibrary("rmgen");
 Engine.LoadLibrary("rmbiome");
 Engine.LoadLibrary("heightmap");
 
 InitMap();
 
 let genStartTime = Date.now();
 
 /**
  * getArray - To ensure a terrain texture is contained within an array
  */
 function getArray(stringOrArrayOfStrings)
 {
 	if (typeof stringOrArrayOfStrings == "string")
 		return [stringOrArrayOfStrings];
 	return stringOrArrayOfStrings;
 }
 
 setSelectedBiome();
 
 // Terrain, entities and actors
 let wildLakeBiome = [
 	// 0 Deep water
 	{
 		"texture": getArray(g_Terrains.water),
 		"actor": [[g_Gaia.fish], 0.01],
 		"textureHS": getArray(g_Terrains.water),
 		"actorHS": [[g_Gaia.fish], 0.03]
 	},
 	// 1 Shallow water
 	{
 		"texture": getArray(g_Terrains.water),
 		"actor": [[g_Decoratives.lillies, g_Decoratives.reeds], 0.3],
 		"textureHS": getArray(g_Terrains.water),
 		"actorHS": [[g_Decoratives.lillies], 0.1]
 	},
 	// 2 Shore
 	{
 		"texture": getArray(g_Terrains.shore),
 		"actor": [
 			[
 				g_Gaia.tree1, g_Gaia.tree1,
 				g_Gaia.tree2, g_Gaia.tree2,
 				g_Gaia.mainHuntableAnimal,
 				g_Decoratives.grass, g_Decoratives.grass,
 				g_Decoratives.rockMedium, g_Decoratives.rockMedium,
 				g_Decoratives.bushMedium, g_Decoratives.bushMedium
 			],
 			0.3
 		],
 		"textureHS": getArray(g_Terrains.cliff),
 		"actorHS": [[g_Decoratives.grassShort, g_Decoratives.rockMedium, g_Decoratives.bushSmall], 0.1]
 	},
 	// 3 Low ground
 	{
 		"texture": getArray(g_Terrains.tier1Terrain),
 		"actor": [
 			[
 				g_Decoratives.grass,
 				g_Decoratives.grassShort,
 				g_Decoratives.rockLarge,
 				g_Decoratives.rockMedium,
 				g_Decoratives.bushMedium,
 				g_Decoratives.bushSmall
 			],
 			0.2
 		],
 		"textureHS": getArray(g_Terrains.cliff),
 		"actorHS": [[g_Decoratives.grassShort, g_Decoratives.rockMedium, g_Decoratives.bushSmall], 0.1]
 	},
 	// 4 Mid ground. Player and path height
 	{
 		"texture": getArray(g_Terrains.mainTerrain),
 		"actor": [
 			[
 				g_Decoratives.grass,
 				g_Decoratives.grassShort,
 				g_Decoratives.rockLarge,
 				g_Decoratives.rockMedium,
 				g_Decoratives.bushMedium,
 				g_Decoratives.bushSmall
 			],
 			0.2
 		],
 		"textureHS": getArray(g_Terrains.cliff),
 		"actorHS": [[g_Decoratives.grassShort, g_Decoratives.rockMedium, g_Decoratives.bushSmall], 0.1]
 	},
 	// 5 High ground
 	{
 		"texture": getArray(g_Terrains.tier2Terrain),
 		"actor": [
 			[
 				g_Decoratives.grass,
 				g_Decoratives.grassShort,
 				g_Decoratives.rockLarge,
 				g_Decoratives.rockMedium,
 				g_Decoratives.bushMedium,
 				g_Decoratives.bushSmall
 			],
 			0.2
 		],
 		"textureHS": getArray(g_Terrains.cliff),
 		"actorHS": [[g_Decoratives.grassShort, g_Decoratives.rockMedium, g_Decoratives.bushSmall], 0.1]
 	},
 	// 6 Lower hilltop forest border
 	{
 		"texture": getArray(g_Terrains.dirt),
 		"actor": [
 			[
 				g_Gaia.tree1,
 				g_Gaia.tree3,
 				g_Gaia.fruitBush,
 				g_Gaia.secondaryHuntableAnimal,
 				g_Decoratives.grass,
 				g_Decoratives.rockMedium,
 				g_Decoratives.bushMedium
 			],
 			0.3
 		],
 		"textureHS": getArray(g_Terrains.cliff),
 		"actorHS": [[g_Decoratives.grassShort, g_Decoratives.rockMedium, g_Decoratives.bushSmall], 0.1]
 	},
 	// 7 Hilltop forest
 	{
 		"texture": getArray(g_Terrains.forestFloor1),
 		"actor": [
 			[
 				g_Gaia.tree1,
 				g_Gaia.tree2,
 				g_Gaia.tree3,
 				g_Gaia.tree4,
 				g_Gaia.tree5,
 				g_Decoratives.tree,
 				g_Decoratives.grass,
 				g_Decoratives.rockMedium,
 				g_Decoratives.bushMedium
 			],
 			0.5
 		],
 		"textureHS": getArray(g_Terrains.cliff),
 		"actorHS": [[g_Decoratives.grassShort, g_Decoratives.rockMedium, g_Decoratives.bushSmall], 0.1]
 	}
 ];
 
 var mercenaryCampGuards = {
 	"temperate": [
 		{ "Template" : "structures/merc_camp_egyptian" },
 		{ "Template" : "units/mace_infantry_javelinist_b", "Count" : 4 },
 		{ "Template" : "units/mace_cavalry_spearman_e", "Count" : 3 },
 		{ "Template" : "units/mace_infantry_archer_a", "Count" : 4 },
 		{ "Template" : "units/mace_champion_infantry_a", "Count" : 3 }
 	],
 	"snowy": [
 		{ "Template" : "structures/ptol_mercenary_camp" },
 		{ "Template" : "units/brit_infantry_javelinist_b", "Count" : 4 },
 		{ "Template" : "units/brit_cavalry_swordsman_e", "Count" : 3 },
 		{ "Template" : "units/brit_infantry_slinger_a", "Count" : 4 },
 		{ "Template" : "units/brit_champion_infantry", "Count" : 3 }
 	],
 	"desert": [
 		{ "Template" : "structures/ptol_mercenary_camp" },
 		{ "Template" : "units/pers_infantry_javelinist_b", "Count" : 4 },
 		{ "Template" : "units/pers_cavalry_swordsman_e", "Count" : 3 },
 		{ "Template" : "units/pers_infantry_archer_a", "Count" : 4 },
 		{ "Template" : "units/pers_champion_infantry", "Count" : 3 }
 	],
 	"alpine": [
 		{ "Template" : "structures/ptol_mercenary_camp" },
 		{ "Template" : "units/rome_infantry_swordsman_b", "Count" : 4 },
 		{ "Template" : "units/rome_cavalry_spearman_e", "Count" : 3 },
 		{ "Template" : "units/rome_infantry_javelinist_a", "Count" : 4 },
 		{ "Template" : "units/rome_champion_infantry", "Count" : 3 }
 	],
 	"mediterranean": [
 		{ "Template" : "structures/merc_camp_egyptian" },
 		{ "Template" : "units/iber_infantry_javelinist_b", "Count" : 4 },
 		{ "Template" : "units/iber_cavalry_spearman_e", "Count" : 3 },
 		{ "Template" : "units/iber_infantry_slinger_a", "Count" : 4 },
 		{ "Template" : "units/iber_champion_infantry", "Count" : 3 }
 	],
 	"savanna": [
 		{ "Template" : "structures/merc_camp_egyptian" },
 		{ "Template" : "units/sele_infantry_javelinist_b", "Count" : 4 },
 		{ "Template" : "units/sele_cavalry_spearman_merc_e", "Count" : 3 },
 		{ "Template" : "units/sele_infantry_spearman_a", "Count" : 4 },
 		{ "Template" : "units/sele_champion_infantry_swordsman", "Count" : 3 }
 	],
 	"tropic": [
 		{ "Template" : "structures/merc_camp_egyptian" },
 		{ "Template" : "units/ptol_infantry_javelinist_b", "Count" : 4 },
 		{ "Template" : "units/ptol_cavalry_archer_e", "Count" : 3 },
 		{ "Template" : "units/ptol_infantry_slinger_a", "Count" : 4 },
 		{ "Template" : "units/ptol_champion_infantry_pikeman", "Count" : 3 }
 	],
 	"autumn": [
 		{ "Template" : "structures/ptol_mercenary_camp" },
 		{ "Template" : "units/gaul_infantry_javelinist_b", "Count" : 4 },
 		{ "Template" : "units/gaul_cavalry_swordsman_e", "Count" : 3 },
 		{ "Template" : "units/gaul_infantry_slinger_a", "Count" : 4 },
 		{ "Template" : "units/gaul_champion_infantry", "Count" : 3 }
 	]
 };
 
 /**
  * Resource spots and other points of interest
  */
 
 // Mines
 function placeMine(point, centerEntity,
 	decorativeActors = [
 		g_Decoratives.grass, g_Decoratives.grassShort,
 		g_Decoratives.rockLarge, g_Decoratives.rockMedium,
 		g_Decoratives.bushMedium, g_Decoratives.bushSmall
 	]
 )
 {
 	placeObject(point.x, point.y, centerEntity, 0, randFloat(0, TWO_PI));
 	let quantity = randIntInclusive(11, 23);
 	let dAngle = TWO_PI / quantity;
 	for (let i = 0; i < quantity; ++i)
 	{
 		let angle = dAngle * randFloat(i, i + 1);
 		let dist = randFloat(2, 5);
 		placeObject(point.x + dist * Math.cos(angle), point.y + dist * Math.sin(angle), pickRandom(decorativeActors), 0, randFloat(0, 2 * PI));
 	}
 }
 
 // Groves, only Wood
 let groveActors = [g_Decoratives.grass, g_Decoratives.rockMedium, g_Decoratives.bushMedium];
 let clGrove = createTileClass();
 
 function placeGrove(point,
 	groveEntities = [
 		g_Gaia.tree1, g_Gaia.tree1, g_Gaia.tree1, g_Gaia.tree1, g_Gaia.tree1,
 		g_Gaia.tree2, g_Gaia.tree2, g_Gaia.tree2, g_Gaia.tree2,
 		g_Gaia.tree3, g_Gaia.tree3, g_Gaia.tree3,
 		g_Gaia.tree4, g_Gaia.tree4, g_Gaia.tree5
 	],
 	groveActors = [g_Decoratives.grass, g_Decoratives.rockMedium, g_Decoratives.bushMedium], groveTileClass = undefined,
 	groveTerrainTexture = getArray(g_Terrains.forestFloor1)
 )
 {
 	placeObject(point.x, point.y, pickRandom(["structures/gaul_outpost", "gaia/flora_tree_oak_new"]), 0, randFloat(0, 2 * PI));
 	let quantity = randIntInclusive(20, 30);
 	let dAngle = TWO_PI / quantity;
 	for (let i = 0; i < quantity; ++i)
 	{
 		let angle = dAngle * randFloat(i, i + 1);
 		let dist = randFloat(2, 5);
 		let objectList = groveEntities;
 		if (i % 3 == 0)
 			objectList = groveActors;
 		let x = point.x + dist * Math.cos(angle);
 		let y = point.y + dist * Math.sin(angle);
 		placeObject(x, y, pickRandom(objectList), 0, randFloat(0, 2 * PI));
 		if (groveTileClass)
 			createArea(new ClumpPlacer(5, 1, 1, 1, floor(x), floor(y)), [new TerrainPainter(groveTerrainTexture), paintClass(groveTileClass)]);
 		else
 			createArea(new ClumpPlacer(5, 1, 1, 1, floor(x), floor(y)), [new TerrainPainter(groveTerrainTexture)]);
 	}
 }
 
 var farmEntities = {
 	"temperate": { "building": "structures/mace_farmstead", "animal": "gaia/fauna_pig" },
 	"snowy": { "building": "structures/brit_farmstead", "animal": "gaia/fauna_sheep" },
 	"desert": { "building": "structures/pers_farmstead", "animal": "gaia/fauna_camel" },
 	"alpine": { "building": "structures/rome_farmstead", "animal": "gaia/fauna_sheep" },
 	"mediterranean": { "building": "structures/iber_farmstead", "animal": "gaia/fauna_pig" },
 	"savanna": { "building": "structures/sele_farmstead", "animal": "gaia/fauna_horse" },
 	"tropic": { "building": "structures/ptol_farmstead", "animal": "gaia/fauna_camel" },
 	"autumn": { "building": "structures/gaul_farmstead", "animal": "gaia/fauna_horse" }
 };
 
 g_WallStyles.other = {
 	"overlap": 0,
 	"fence": readyWallElement("other/fence_long", "gaia"),
 	"fence_short": readyWallElement("other/fence_short", "gaia"),
 	"bench":     { "angle": Math.PI / 2, "length": 1.5,  "indent": 0,    "bend": 0, "templateName": "other/bench" },
 	"foodBin":   { "angle": Math.PI / 2, "length": 1.5,  "indent": 0,    "bend": 0, "templateName": "gaia/special_treasure_food_bin" },
 	"animal":    { "angle": 0,           "length": 0,    "indent": 0.75, "bend": 0, "templateName": farmEntities[currentBiome()].animal },
 	"farmstead": { "angle": Math.PI,     "length": 0,    "indent": -3,   "bend": 0, "templateName": farmEntities[currentBiome()].building }
 };
 
 let fences = [
 	new Fortress("fence", [
 		"foodBin", "farmstead", "bench",
 		"turn_0.25", "animal", "turn_0.25", "fence",
 		"turn_0.25", "animal", "turn_0.25", "fence",
 		"turn_0.25", "animal", "turn_0.25", "fence"
 	]),
 	new Fortress("fence", [
 		"foodBin", "farmstead", "fence",
 		"turn_0.25", "animal", "turn_0.25", "fence",
 		"turn_0.25", "animal", "turn_0.25", "bench", "animal", "fence",
 		"turn_0.25", "animal", "turn_0.25", "fence"
 	]),
 	new Fortress("fence", [
 		"foodBin", "farmstead", "turn_0.5", "bench", "turn_-0.5", "fence_short",
 		"turn_0.25", "animal", "turn_0.25", "fence",
 		"turn_0.25", "animal", "turn_0.25", "fence",
 		"turn_0.25", "animal", "turn_0.25", "fence_short", "animal", "fence"
 	]),
 	new Fortress("fence", [
 		"foodBin", "farmstead", "turn_0.5", "fence_short", "turn_-0.5", "bench",
 		"turn_0.25", "animal", "turn_0.25", "fence",
 		"turn_0.25", "animal", "turn_0.25", "fence",
 		"turn_0.25", "animal", "turn_0.25", "fence_short", "animal", "fence"
 	]),
 	new Fortress("fence", [
 		"foodBin", "farmstead", "fence",
 		"turn_0.25", "animal", "turn_0.25", "bench", "animal", "fence",
 		"turn_0.25", "animal", "turn_0.25", "fence_short", "animal", "fence",
 		"turn_0.25", "animal", "turn_0.25", "fence_short", "animal", "fence"
 	])
 ];
 let num = fences.length;
 for (let i = 0; i < num; ++i)
 	fences.push(new Fortress("fence", clone(fences[i].wall).reverse()));
 
 // Camps with fire and gold treasure
 function placeCamp(point,
 	centerEntity = "actor|props/special/eyecandy/campfire.xml",
 	otherEntities = ["gaia/special_treasure_metal", "gaia/special_treasure_standing_stone",
 		"units/brit_infantry_slinger_b", "units/brit_infantry_javelinist_b", "units/gaul_infantry_slinger_b", "units/gaul_infantry_javelinist_b", "units/gaul_champion_fanatic",
 		"actor|props/special/common/waypoint_flag.xml", "actor|props/special/eyecandy/barrel_a.xml", "actor|props/special/eyecandy/basket_celt_a.xml", "actor|props/special/eyecandy/crate_a.xml", "actor|props/special/eyecandy/dummy_a.xml", "actor|props/special/eyecandy/handcart_1.xml", "actor|props/special/eyecandy/handcart_1_broken.xml", "actor|props/special/eyecandy/sack_1.xml", "actor|props/special/eyecandy/sack_1_rough.xml"
 	]
 )
 {
 	placeObject(point.x, point.y, centerEntity, 0, randFloat(0, TWO_PI));
 	let quantity = randIntInclusive(5, 11);
 	let dAngle = TWO_PI / quantity;
 	for (let i = 0; i < quantity; ++i)
 	{
 		let angle = dAngle * randFloat(i, i + 1);
 		let dist = randFloat(1, 3);
 		placeObject(point.x + dist * Math.cos(angle), point.y + dist * Math.sin(angle), pickRandom(otherEntities), 0, randFloat(0, 2 * PI));
 	}
 }
 
 function placeStartLocationResources(
 	point,
 	foodEntities = [g_Gaia.fruitBush, g_Gaia.chicken],
 	groveEntities = [
 		g_Gaia.tree1, g_Gaia.tree1, g_Gaia.tree1, g_Gaia.tree1, g_Gaia.tree1,
 		g_Gaia.tree2, g_Gaia.tree2, g_Gaia.tree2, g_Gaia.tree2,
 		g_Gaia.tree3, g_Gaia.tree3, g_Gaia.tree3,
 		g_Gaia.tree4, g_Gaia.tree4, g_Gaia.tree5
 	],
 	groveTerrainTexture = getArray(g_Terrains.forestFloor1),
 	averageDistToCC = 10,
 	dAverageDistToCC = 2
 )
 {
 	function getRandDist()
 	{
 		return averageDistToCC + randFloat(-dAverageDistToCC, dAverageDistToCC);
 	}
 
 	let currentAngle = randFloat(0, TWO_PI);
 	// Stone
 	let dAngle = TWO_PI * 2 / 9;
 	let angle = currentAngle + randFloat(dAngle / 4, 3 * dAngle / 4);
 	placeMine({ "x": point.x + averageDistToCC * Math.cos(angle), "y": point.y + averageDistToCC * Math.sin(angle) }, g_Gaia.stoneLarge);
 
 	currentAngle += dAngle;
 
 	// Wood
 	let quantity = 80;
 	dAngle = TWO_PI / quantity / 3;
 	for (let i = 0; i < quantity; ++i)
 	{
 		angle = currentAngle + randFloat(0, dAngle);
 		let dist = getRandDist();
 		let objectList = groveEntities;
 		if (i % 2 == 0)
 			objectList = groveActors;
 		let x = point.x + dist * Math.cos(angle);
 		let y = point.y + dist * Math.sin(angle);
 		placeObject(x, y, pickRandom(objectList), 0, randFloat(0, 2 * PI));
 		createArea(new ClumpPlacer(5, 1, 1, 1, floor(x), floor(y)), [new TerrainPainter(groveTerrainTexture), paintClass(clGrove)]);
 		currentAngle += dAngle;
 	}
 
 	// Metal
 	dAngle = TWO_PI * 2 / 9;
 	angle = currentAngle + randFloat(dAngle / 4, 3 * dAngle / 4);
 	placeMine({ "x": point.x + averageDistToCC * Math.cos(angle), "y": point.y + averageDistToCC * Math.sin(angle) }, g_Gaia.metalLarge);
 	currentAngle += dAngle;
 
 	// Berries and domestic animals
 	quantity = 15;
 	dAngle = TWO_PI / quantity * 2 / 9;
 	for (let i = 0; i < quantity; ++i)
 	{
 		angle = currentAngle + randFloat(0, dAngle);
 		let dist = getRandDist();
 		placeObject(point.x + dist * Math.cos(angle), point.y + dist * Math.sin(angle), pickRandom(foodEntities), 0, randFloat(0, 2 * PI));
 		currentAngle += dAngle;
 	}
 }
 
 log("Functions loaded after " + ((Date.now() - genStartTime) / 1000) + "s");
 
 /**
  * Base terrain shape generation and settings
  */
  // Height range by map size
 let heightScale = (g_Map.size + 256) / 768 / 4;
 let heightRange = { "min": MIN_HEIGHT * heightScale, "max": MAX_HEIGHT * heightScale };
 
 // Water coverage
 let averageWaterCoverage = 1/5; // NOTE: Since terrain generation is quite unpredictable actual water coverage might vary much with the same value
 let waterHeight = -MIN_HEIGHT + heightRange.min + averageWaterCoverage * (heightRange.max - heightRange.min); // Water height in environment and the engine
 let waterHeightAdjusted = waterHeight + MIN_HEIGHT; // Water height as terrain height
 setWaterHeight(waterHeight);
 
 // Generate base terrain shape
 let lowH = heightRange.min;
 let medH = (heightRange.min + heightRange.max) / 2;
 
 // Lake
 let initialHeightmap = [
 	[medH, medH, medH, medH, medH, medH],
 	[medH, medH, medH, medH, medH, medH],
 	[medH, medH, lowH, lowH, medH, medH],
 	[medH, medH, lowH, lowH, medH, medH],
 	[medH, medH, medH, medH, medH, medH],
 	[medH, medH, medH, medH, medH, medH],
 ];
 if (g_Map.size < 256)
 {
 	initialHeightmap = [
 		[medH, medH, medH, medH, medH],
 		[medH, medH, medH, medH, medH],
 		[medH, medH, lowH, medH, medH],
 		[medH, medH, medH, medH, medH],
 		[medH, medH, medH, medH, medH]
 	];
 }
 if (g_Map.size >= 384)
 {
 	initialHeightmap = [
 		[medH, medH, medH, medH, medH, medH, medH, medH],
 		[medH, medH, medH, medH, medH, medH, medH, medH],
 		[medH, medH, medH, medH, medH, medH, medH, medH],
 		[medH, medH, medH, lowH, lowH, medH, medH, medH],
 		[medH, medH, medH, lowH, lowH, medH, medH, medH],
 		[medH, medH, medH, medH, medH, medH, medH, medH],
 		[medH, medH, medH, medH, medH, medH, medH, medH],
 		[medH, medH, medH, medH, medH, medH, medH, medH],
 	];
 }
 
 setBaseTerrainDiamondSquare(heightRange.min, heightRange.max, initialHeightmap, 0.8);
 
 // Apply simple erosion
 for (let i = 0; i < 5; ++i)
 	splashErodeMap(0.1);
 globalSmoothHeightmap();
 
 // Final rescale
 rescaleHeightmap(heightRange.min, heightRange.max);
 
 Engine.SetProgress(25);
 
 /**
  * Prepare terrain texture placement
  */
 let heighLimits = [
 	heightRange.min + 3/4 * (waterHeightAdjusted - heightRange.min), // 0 Deep water
 	waterHeightAdjusted, // 1 Shallow water
 	waterHeightAdjusted + 2/8 * (heightRange.max - waterHeightAdjusted), // 2 Shore
 	waterHeightAdjusted + 3/8 * (heightRange.max - waterHeightAdjusted), // 3 Low ground
 	waterHeightAdjusted + 4/8 * (heightRange.max - waterHeightAdjusted), // 4 Player and path height
 	waterHeightAdjusted + 6/8 * (heightRange.max - waterHeightAdjusted), // 5 High ground
 	waterHeightAdjusted + 7/8 * (heightRange.max - waterHeightAdjusted), // 6 Lower forest border
 	heightRange.max // 7 Forest
 ];
 let playerHeightRange = { "min" : heighLimits[3], "max" : heighLimits[4] };
 let resourceSpotHeightRange = { "min" : (heighLimits[2] + heighLimits[3]) / 2, "max" : (heighLimits[4] + heighLimits[5]) / 2 };
 let playerHeight = (playerHeightRange.min + playerHeightRange.max) / 2; // Average player height
 
 log("Terrain shape generation and biome presets after " + ((Date.now() - genStartTime) / 1000) + "s");
 
 let [playerIDs, startLocations] = sortPlayersByLocation(getStartLocationsByHeightmap(playerHeightRange, 1000, 30));
 
 log("Start location chosen after " + ((Date.now() - genStartTime) / 1000) + "s");
 Engine.SetProgress(30);
 
 /**
  * Smooth Start Locations before height region calculation
  */
 let playerBaseRadius = 35;
 if (g_Map.size < 256)
 	playerBaseRadius = 25;
 for (let p = 0; p < playerIDs.length; ++p)
 	rectangularSmoothToHeight(startLocations[p], playerBaseRadius, playerBaseRadius, playerHeight, 0.7);
 
 /**
  * Calculate tile centered height map after start position smoothing but before placing paths
  * This has nothing to to with TILE_CENTERED_HEIGHT_MAP which should be false!
  */
 let tchm = getTileCenteredHeightmap();
 
 /**
  * Add paths (If any)
  */
 let clPath = createTileClass();
 
 /**
  * Divide tiles in areas by height and avoid paths
  */
 let areas = [];
 for (let h = 0; h < heighLimits.length; ++h)
 	areas.push([]);
 
 for (let x = 0; x < tchm.length; ++x)
 {
 	for (let y = 0; y < tchm[0].length; ++y)
 	{
 		if (g_Map.tileClasses[clPath].inclusionCount[x][y] > 0) // Avoid paths
 			continue;
 
 		let minHeight = heightRange.min;
 		for (let h = 0; h < heighLimits.length; ++h)
 		{
 			if (tchm[x][y] >= minHeight && tchm[x][y] <= heighLimits[h])
 			{
 				areas[h].push({ "x": x, "y": y });
 				break;
 			}
 			else
 				minHeight = heighLimits[h];
 		}
 	}
 }
 
 /**
  * Get max slope of each area
  */
 let slopeMap = getSlopeMap();
 let minSlope = [];
 let maxSlope = [];
 for (let h = 0; h < heighLimits.length; ++h)
 {
 	minSlope[h] = Infinity;
 	maxSlope[h] = 0;
 	for (let t = 0; t < areas[h].length; ++t)
 	{
 		let x = areas[h][t].x;
 		let y = areas[h][t].y;
 		let slope = slopeMap[x][y];
 
 		if (slope > maxSlope[h])
 			maxSlope[h] = slope;
 
 		if (slope < minSlope[h])
 			minSlope[h] = slope;
 	}
 }
 
 /**
  * Paint areas by height and slope
  */
 for (let h = 0; h < heighLimits.length; ++h)
 {
 	for (let t = 0; t < areas[h].length; ++t)
 	{
 		let x = areas[h][t].x;
 		let y = areas[h][t].y;
 		let actor;
 		let texture = pickRandom(wildLakeBiome[h].texture);
 
 		if (slopeMap[x][y] < 0.5 * (minSlope[h] + maxSlope[h]))
 		{
 			if (randBool(wildLakeBiome[h].actor[1]))
 				actor = pickRandom(wildLakeBiome[h].actor[0]);
 		}
 		else
 		{
 			texture = pickRandom(wildLakeBiome[h].textureHS);
 			if (randBool(wildLakeBiome[h].actorHS[1]))
 				actor = pickRandom(wildLakeBiome[h].actorHS[0]);
 		}
 
 		g_Map.texture[x][y] = g_Map.getTextureID(texture);
 
 		if (actor)
 			placeObject(randFloat(x, x + 1), randFloat(y, y + 1), actor, 0, randFloat(0, 2 * PI));
 	}
 }
 
 log("Terrain texture placement finished after " + ((Date.now() - genStartTime) / 1000) + "s");
 Engine.SetProgress(80);
 
 /**
  * Get resource spots after players start locations calculation and paths
  */
 let avoidPoints = clone(startLocations);
 for (let i = 0; i < avoidPoints.length; ++i)
 	avoidPoints[i].dist = 30;
 let resourceSpots = getPointsByHeight(resourceSpotHeightRange, avoidPoints, clPath);
 
 log("Resource spots chosen after " + ((Date.now() - genStartTime) / 1000) + "s");
 Engine.SetProgress(55);
 
 /**
  * Add start locations and resource spots after terrain texture and path painting
  */
 for (let p = 0; p < playerIDs.length; ++p)
 {
 	let point = startLocations[p];
 	placeCivDefaultEntities(point.x, point.y, playerIDs[p], { "iberWall": g_Map.size > 192 });
 	placeStartLocationResources(point);
 }
 
-let mercenaryCamps = ceil(g_Map.size / 256);
+let mercenaryCamps = Math.ceil(g_Map.size / 256);
 log("Maximum number of mercenary camps: " + uneval(mercenaryCamps));
 for (let i = 0; i < resourceSpots.length; ++i)
 {
 	let choice = i % 5;
 	if (choice == 0)
 		placeMine(resourceSpots[i], g_Gaia.stoneLarge);
 	if (choice == 1)
 		placeMine(resourceSpots[i], g_Gaia.metalLarge);
 	if (choice == 2)
 		placeGrove(resourceSpots[i]);
 	if (choice == 3)
 	{
 		placeCamp(resourceSpots[i]);
 		rectangularSmoothToHeight(resourceSpots[i], 5, 5, g_Map.height[resourceSpots[i].x][resourceSpots[i].y] - 10, 0.5);
 	}
 	if (choice == 4)
 	{
 		if (mercenaryCamps)
 		{
 			placeStartingEntities(resourceSpots[i].x, resourceSpots[i].y, 0, mercenaryCampGuards[currentBiome()]);
 			rectangularSmoothToHeight(resourceSpots[i], 15, 15, g_Map.height[resourceSpots[i].x][resourceSpots[i].y], 0.5);
 			--mercenaryCamps;
 		}
 		else
 		{
 			placeCustomFortress(resourceSpots[i].x, resourceSpots[i].y, pickRandom(fences), "other", 0, randFloat(0, 2 * PI));
 			rectangularSmoothToHeight(resourceSpots[i], 10, 10, g_Map.height[resourceSpots[i].x][resourceSpots[i].y], 0.5);
 		}
 	}
 }
 
 log("Map generation finished after " + ((Date.now() - genStartTime) / 1000) + "s");
 
 ExportMap();